sig
  module Monoid :
    sig
      module type Base =
        sig
          type t
          val zero : Monads.Std.Monoid.Base.t
          val plus :
            Monads.Std.Monoid.Base.t ->
            Monads.Std.Monoid.Base.t -> Monads.Std.Monoid.Base.t
        end
      module type S =
        sig
          type t
          val zero : t
          val plus : t -> t -> t
          val concat : t list -> t
          val ( @@ ) : t -> t -> t
        end
      module Make :
        functor (M : Base->
          sig
            val zero : M.t
            val plus : M.t -> M.t -> M.t
            val concat : M.t list -> M.t
            val ( @@ ) : M.t -> M.t -> M.t
          end
      module Unit :
        sig
          type t = unit
          val zero : t
          val plus : t -> t -> t
          val concat : t list -> t
          val ( @@ ) : t -> t -> t
        end
      module TList : functor (T : Core_kernel.T-> sig type t = T.t list end
      module Stack :
        sig
          module Make :
            functor (T : Core_kernel.T->
              sig
                val zero : TList(T).t
                val plus : TList(T).t -> TList(T).t -> TList(T).t
                val concat : TList(T).t list -> TList(T).t
                val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t
              end
        end
      module List :
        sig
          module Make :
            functor (T : Core_kernel.T->
              sig
                val zero : TList(T).t
                val plus : TList(T).t -> TList(T).t -> TList(T).t
                val concat : TList(T).t list -> TList(T).t
                val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t
              end
        end
      module String :
        sig
          type t = string
          val zero : t
          val plus : t -> t -> t
          val concat : t list -> t
          val ( @@ ) : t -> t -> t
        end
      module Set :
        sig
          module Make :
            functor (S : Core_kernel.Set.S->
              sig
                val zero : S.t
                val plus : S.t -> S.t -> S.t
                val concat : S.t list -> S.t
                val ( @@ ) : S.t -> S.t -> S.t
              end
        end
      module Int :
        sig
          type t = int
          val zero : t
          val plus : t -> t -> t
          val concat : t list -> t
          val ( @@ ) : t -> t -> t
          module Sum :
            sig
              type t = int
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
          module Product :
            sig
              type t = Sum.t
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
        end
      module Float :
        sig
          type t = float
          val zero : t
          val plus : t -> t -> t
          val concat : t list -> t
          val ( @@ ) : t -> t -> t
          module Sum :
            sig
              type t = float
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
          module Product :
            sig
              type t = Sum.t
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
        end
    end
  module Monad :
    sig
      module Plus :
        sig
          module type S =
            sig
              type 'a t
              val zero : unit -> 'Monads.Std.Monad.Plus.S.t
              val plus :
                'Monads.Std.Monad.Plus.S.t ->
                'Monads.Std.Monad.Plus.S.t -> 'Monads.Std.Monad.Plus.S.t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              val zero : unit -> ('a, 'e) Monads.Std.Monad.Plus.S2.t
              val plus :
                ('a, 'e) Monads.Std.Monad.Plus.S2.t ->
                ('a, 'e) Monads.Std.Monad.Plus.S2.t ->
                ('a, 'e) Monads.Std.Monad.Plus.S2.t
            end
        end
      module Fail :
        sig
          module type S =
            sig
              type 'a error
              type 'a t
              val fail :
                'Monads.Std.Monad.Fail.S.error ->
                'Monads.Std.Monad.Fail.S.t
              val catch :
                'Monads.Std.Monad.Fail.S.t ->
                ('Monads.Std.Monad.Fail.S.error ->
                 'Monads.Std.Monad.Fail.S.t) ->
                'Monads.Std.Monad.Fail.S.t
            end
          module type S2 =
            sig
              type 'a error
              type ('a, 'e) t
              val fail :
                'Monads.Std.Monad.Fail.S2.error ->
                ('a, 'e) Monads.Std.Monad.Fail.S2.t
              val catch :
                ('a, 'e) Monads.Std.Monad.Fail.S2.t ->
                ('Monads.Std.Monad.Fail.S2.error ->
                 ('a, 'e) Monads.Std.Monad.Fail.S2.t) ->
                ('a, 'e) Monads.Std.Monad.Fail.S2.t
            end
        end
      module Choice :
        sig
          module type Basic =
            sig
              type 'a t
              val pure : '-> 'Monads.Std.Monad.Choice.Basic.t
              val zero : unit -> 'Monads.Std.Monad.Choice.Basic.t
            end
          module type S =
            sig
              type 'a t
              val pure : '-> 'a t
              val zero : Monoid.Unit.t -> 'a t
              val accept : '-> 'Monads.Std.Monad.Choice.S.t
              val reject : unit -> 'Monads.Std.Monad.Choice.S.t
              val guard : bool -> unit Monads.Std.Monad.Choice.S.t
              val on :
                bool ->
                unit Monads.Std.Monad.Choice.S.t ->
                unit Monads.Std.Monad.Choice.S.t
              val unless :
                bool ->
                unit Monads.Std.Monad.Choice.S.t ->
                unit Monads.Std.Monad.Choice.S.t
            end
          module type Basic2 =
            sig
              type ('a, 'e) t
              val pure : '-> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
              val zero : unit -> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              val pure : '-> ('a, 'e) t
              val zero : Monoid.Unit.t -> ('a, 'e) t
              val accept : '-> ('a, 'e) Monads.Std.Monad.Choice.S2.t
              val reject : unit -> ('a, 'e) Monads.Std.Monad.Choice.S2.t
              val guard : bool -> (unit, 'e) Monads.Std.Monad.Choice.S2.t
              val on :
                bool ->
                (unit, 'e) Monads.Std.Monad.Choice.S2.t ->
                (unit, 'e) Monads.Std.Monad.Choice.S2.t
              val unless :
                bool ->
                (unit, 'e) Monads.Std.Monad.Choice.S2.t ->
                (unit, 'e) Monads.Std.Monad.Choice.S2.t
            end
          module Make :
            functor (M : Basic->
              sig
                val pure : '-> 'M.t
                val zero : Monoid.Unit.t -> 'M.t
                val accept : '-> 'M.t
                val reject : Monoid.Unit.t -> 'M.t
                val guard : bool -> Monoid.Unit.t M.t
                val on : bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t
                val unless : bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t
              end
          module Make2 :
            functor (M : Basic2->
              sig
                val pure : '-> ('a, 'e) M.t
                val zero : Monoid.Unit.t -> ('a, 'e) M.t
                val accept : '-> ('a, 'e) M.t
                val reject : Monoid.Unit.t -> ('a, 'e) M.t
                val guard : bool -> (Monoid.Unit.t, 'e) M.t
                val on :
                  bool -> (Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                val unless :
                  bool -> (Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
              end
        end
      module Trans :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift :
                'Monads.Std.Monad.Trans.S.m ->
                'Monads.Std.Monad.Trans.S.t
              val run :
                'Monads.Std.Monad.Trans.S.t ->
                'Monads.Std.Monad.Trans.S.e
            end
          module type S1 =
            sig
              type ('a, 'e) t
              type 'a m
              type ('a, 'e) e
              val lift :
                'Monads.Std.Monad.Trans.S1.m ->
                ('a, 'e) Monads.Std.Monad.Trans.S1.t
              val run :
                ('a, 'e) Monads.Std.Monad.Trans.S1.t ->
                ('a, 'e) Monads.Std.Monad.Trans.S1.e
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type ('a, 'e) m
              type ('a, 'e) e
              val lift :
                ('a, 'e) Monads.Std.Monad.Trans.S2.m ->
                ('a, 'e) Monads.Std.Monad.Trans.S2.t
              val run :
                ('a, 'e) Monads.Std.Monad.Trans.S2.t ->
                ('a, 'e) Monads.Std.Monad.Trans.S2.e
            end
        end
      module type Basic =
        sig
          type 'a t
          val bind :
            'Monads.Std.Monad.Basic.t ->
            ('-> 'Monads.Std.Monad.Basic.t) ->
            'Monads.Std.Monad.Basic.t
          val return : '-> 'Monads.Std.Monad.Basic.t
          val map :
            [ `Custom of
                'Monads.Std.Monad.Basic.t ->
                f:('-> 'b) -> 'Monads.Std.Monad.Basic.t
            | `Define_using_bind ]
        end
      module type Basic2 =
        sig
          type ('a, 'e) t
          val bind :
            ('a, 'e) Monads.Std.Monad.Basic2.t ->
            ('-> ('b, 'e) Monads.Std.Monad.Basic2.t) ->
            ('b, 'e) Monads.Std.Monad.Basic2.t
          val map :
            [ `Custom of
                ('a, 'e) Monads.Std.Monad.Basic2.t ->
                f:('-> 'b) -> ('b, 'e) Monads.Std.Monad.Basic2.t
            | `Define_using_bind ]
          val return : '-> ('a, 'b) Monads.Std.Monad.Basic2.t
        end
      module Collection :
        sig
          module type Basic =
            sig
              type 'a t
              val return : '-> 'Monads.Std.Monad.Collection.Basic.t
              val zero : Monoid.Unit.t -> 'a t
              val plus : 'a t -> 'a t -> 'a t
            end
          module type Eager =
            sig
              type 'a t
              val return : '-> 'a t
              val zero : Monoid.Unit.t -> 'a t
              val plus : 'a t -> 'a t -> 'a t
              val fold : 'a t -> init:'-> f:('-> '-> 's) -> 's
            end
          module type Delay =
            sig
              type 'a t
              val return : '-> 'a t
              val zero : Monoid.Unit.t -> 'a t
              val plus : 'a t -> 'a t -> 'a t
              val fold :
                'a t ->
                init:'->
                f:('-> '-> ('-> 'r) -> 'r) -> ('-> 'r) -> 'r
            end
          module type S2 =
            sig
              type ('a, 'e) m
              type 'a t
              val all :
                ('a, 'e) Monads.Std.Monad.Collection.S2.m
                Monads.Std.Monad.Collection.S2.t ->
                ('Monads.Std.Monad.Collection.S2.t, 'e)
                Monads.Std.Monad.Collection.S2.m
              val all_ignore :
                ('a, 'e) Monads.Std.Monad.Collection.S2.m
                Monads.Std.Monad.Collection.S2.t ->
                (unit, 'e) Monads.Std.Monad.Collection.S2.m
              val sequence :
                (unit, 'e) Monads.Std.Monad.Collection.S2.m
                Monads.Std.Monad.Collection.S2.t ->
                (unit, 'e) Monads.Std.Monad.Collection.S2.m
              val map :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('Monads.Std.Monad.Collection.S2.t, 'e)
                Monads.Std.Monad.Collection.S2.m
              val iter :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> (unit, 'e) Monads.Std.Monad.Collection.S2.m) ->
                (unit, 'e) Monads.Std.Monad.Collection.S2.m
              val fold :
                'Monads.Std.Monad.Collection.S2.t ->
                init:'->
                f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('b, 'e) Monads.Std.Monad.Collection.S2.m
              val fold_left :
                'Monads.Std.Monad.Collection.S2.t ->
                init:'->
                f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('b, 'e) Monads.Std.Monad.Collection.S2.m
              val fold_right :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                init:'-> ('b, 'e) Monads.Std.Monad.Collection.S2.m
              val reduce :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> '-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('a option, 'e) Monads.Std.Monad.Collection.S2.m
              val exists :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                (bool, 'e) Monads.Std.Monad.Collection.S2.m
              val for_all :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                (bool, 'e) Monads.Std.Monad.Collection.S2.m
              val count :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                (int, 'e) Monads.Std.Monad.Collection.S2.m
              val map_reduce :
                (module Monads.Std.Monoid.S with type t = 'a) ->
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('a, 'e) Monads.Std.Monad.Collection.S2.m
              val find :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('a option, 'e) Monads.Std.Monad.Collection.S2.m
              val find_map :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('b option, 'e) Monads.Std.Monad.Collection.S2.m
              val filter :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('Monads.Std.Monad.Collection.S2.t, 'e)
                Monads.Std.Monad.Collection.S2.m
              val filter_map :
                'Monads.Std.Monad.Collection.S2.t ->
                f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
                ('Monads.Std.Monad.Collection.S2.t, 'e)
                Monads.Std.Monad.Collection.S2.m
            end
          module type S =
            sig
              type 'a m
              type 'a t
              val all :
                'Monads.Std.Monad.Collection.S.m
                Monads.Std.Monad.Collection.S.t ->
                'Monads.Std.Monad.Collection.S.t
                Monads.Std.Monad.Collection.S.m
              val all_ignore :
                'Monads.Std.Monad.Collection.S.m
                Monads.Std.Monad.Collection.S.t ->
                unit Monads.Std.Monad.Collection.S.m
              val sequence :
                unit Monads.Std.Monad.Collection.S.m
                Monads.Std.Monad.Collection.S.t ->
                unit Monads.Std.Monad.Collection.S.m
              val map :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> 'Monads.Std.Monad.Collection.S.m) ->
                'Monads.Std.Monad.Collection.S.t
                Monads.Std.Monad.Collection.S.m
              val iter :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> unit Monads.Std.Monad.Collection.S.m) ->
                unit Monads.Std.Monad.Collection.S.m
              val fold :
                'Monads.Std.Monad.Collection.S.t ->
                init:'->
                f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                'Monads.Std.Monad.Collection.S.m
              val fold_left :
                'Monads.Std.Monad.Collection.S.t ->
                init:'->
                f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                'Monads.Std.Monad.Collection.S.m
              val fold_right :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                init:'-> 'Monads.Std.Monad.Collection.S.m
              val reduce :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                'a option Monads.Std.Monad.Collection.S.m
              val exists :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                bool Monads.Std.Monad.Collection.S.m
              val for_all :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                bool Monads.Std.Monad.Collection.S.m
              val count :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                int Monads.Std.Monad.Collection.S.m
              val map_reduce :
                (module Monads.Std.Monoid.S with type t = 'a) ->
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> 'Monads.Std.Monad.Collection.S.m) ->
                'Monads.Std.Monad.Collection.S.m
              val find :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                'a option Monads.Std.Monad.Collection.S.m
              val find_map :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->
                'b option Monads.Std.Monad.Collection.S.m
              val filter :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                'Monads.Std.Monad.Collection.S.t
                Monads.Std.Monad.Collection.S.m
              val filter_map :
                'Monads.Std.Monad.Collection.S.t ->
                f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->
                'Monads.Std.Monad.Collection.S.t
                Monads.Std.Monad.Collection.S.m
            end
        end
      module Syntax :
        sig
          module type S =
            sig
              type 'a t
              val ( >>= ) :
                'Monads.Std.Monad.Syntax.S.t ->
                ('-> 'Monads.Std.Monad.Syntax.S.t) ->
                'Monads.Std.Monad.Syntax.S.t
              val ( >>| ) :
                'Monads.Std.Monad.Syntax.S.t ->
                ('-> 'b) -> 'Monads.Std.Monad.Syntax.S.t
              val ( >=> ) :
                ('-> 'Monads.Std.Monad.Syntax.S.t) ->
                ('-> 'Monads.Std.Monad.Syntax.S.t) ->
                '-> 'Monads.Std.Monad.Syntax.S.t
              val ( !! ) : '-> 'Monads.Std.Monad.Syntax.S.t
              val ( !$ ) :
                ('-> 'b) ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t
              val ( !$$ ) :
                ('-> '-> 'c) ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t ->
                'Monads.Std.Monad.Syntax.S.t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              val ( >>= ) :
                ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
                ('b, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( >>| ) :
                ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('-> 'b) -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( >=> ) :
                ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
                ('-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t) ->
                '-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( !! ) : '-> ('a, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( !$ ) :
                ('-> 'b) ->
                ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('b, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( !$$ ) :
                ('-> '-> 'c) ->
                ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('c, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('c, 'e) Monads.Std.Monad.Syntax.S2.t ->
                ('d, 'e) Monads.Std.Monad.Syntax.S2.t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('b, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('c, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('d, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('e, 's) Monads.Std.Monad.Syntax.S2.t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('b, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('c, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('d, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('e, 's) Monads.Std.Monad.Syntax.S2.t ->
                ('f, 's) Monads.Std.Monad.Syntax.S2.t
            end
        end
      module type S =
        sig
          type 'a t
          val void : 'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
          val sequence :
            unit Monads.Std.Monad.S.t list -> unit Monads.Std.Monad.S.t
          val forever : 'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
          module Fn :
            sig
              val id : '-> 'Monads.Std.Monad.S.t
              val ignore :
                'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
              val nothing : unit -> unit Monads.Std.Monad.S.t
              val non :
                ('-> bool Monads.Std.Monad.S.t) ->
                '-> bool Monads.Std.Monad.S.t
              val apply_n_times :
                n:int ->
                ('-> 'Monads.Std.Monad.S.t) ->
                '-> 'Monads.Std.Monad.S.t
              val compose :
                ('-> 'Monads.Std.Monad.S.t) ->
                ('-> 'Monads.Std.Monad.S.t) ->
                '-> 'Monads.Std.Monad.S.t
            end
          module Pair :
            sig
              val fst :
                ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
              val snd :
                ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
            end
          module Triple :
            sig
              val fst :
                ('a * 'b * 'c) Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t
              val snd :
                ('a * 'b * 'c) Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t
              val trd :
                ('a * 'b * 'c) Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t
            end
          module Lift :
            sig
              val nullary : '-> 'Monads.Std.Monad.S.t
              val unary :
                ('-> 'b) ->
                'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
              val binary :
                ('-> '-> 'c) ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
              val ternary :
                ('-> '-> '-> 'd) ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t ->
                'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> unit Monads.Std.Monad.S.t) ->
                f:(unit -> 'Monads.Std.Monad.S.t) ->
                catch:(exn -> 'Monads.Std.Monad.S.t) ->
                'Monads.Std.Monad.S.t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t t -> 'a t t
                  val all_ignore : 'a t t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                  val map : 'a t -> f:('-> 'b t) -> 'b t t
                  val iter :
                    'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a t -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'a t -> f:('-> bool t) -> bool t
                  val for_all : 'a t -> f:('-> bool t) -> bool t
                  val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a t) -> 'a t
                  val find : 'a t -> f:('-> bool t) -> 'a option t
                  val find_map : 'a t -> f:('-> 'b option t) -> 'b option t
                  val filter : 'a t -> f:('-> bool t) -> 'a t t
                  val filter_map : 'a t -> f:('-> 'b option t) -> 'b t t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'a option t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'a option t
                    val find_map :
                      'T.t -> f:('-> 'b option t) -> 'b option t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'b option t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'a option t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'a option t
                    val find_map :
                      'T.t -> f:('-> 'b option t) -> 'b option t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'b option t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t list -> 'a list t
              val all_ignore : 'a t list -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
              val map : 'a list -> f:('-> 'b t) -> 'b list t
              val iter :
                'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
              val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
              val exists : 'a list -> f:('-> bool t) -> bool t
              val for_all : 'a list -> f:('-> bool t) -> bool t
              val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a t) -> 'a t
              val find : 'a list -> f:('-> bool t) -> 'a option t
              val find_map : 'a list -> f:('-> 'b option t) -> 'b option t
              val filter : 'a list -> f:('-> bool t) -> 'a list t
              val filter_map : 'a list -> f:('-> 'b option t) -> 'b list t
            end
          module Seq :
            sig
              val all :
                'a t Core_kernel.Sequence.t -> 'Core_kernel.Sequence.t t
              val all_ignore : 'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
              val sequence :
                Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
              val map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b t) -> 'Core_kernel.Sequence.t t
              val iter :
                'Core_kernel.Sequence.t ->
                f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
              val fold :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Core_kernel.Sequence.t ->
                f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce :
                'Core_kernel.Sequence.t ->
                f:('-> '-> 'a t) -> 'a option t
              val exists :
                'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
              val for_all :
                'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
              val count :
                'Core_kernel.Sequence.t ->
                f:('-> bool t) -> Monoid.Int.t t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
              val find :
                'Core_kernel.Sequence.t -> f:('-> bool t) -> 'a option t
              val find_map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b option t) -> 'b option t
              val filter :
                'Core_kernel.Sequence.t ->
                f:('-> bool t) -> 'Core_kernel.Sequence.t t
              val filter_map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b option t) -> 'Core_kernel.Sequence.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> Monoid.Unit.t t
          val all : 'a t list -> 'a list t
          val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
          val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
        end
      module type S2 =
        sig
          type ('a, 'e) t
          val void :
            ('a, 'e) Monads.Std.Monad.S2.t ->
            (unit, 'e) Monads.Std.Monad.S2.t
          val sequence :
            (unit, 'e) Monads.Std.Monad.S2.t list ->
            (unit, 'e) Monads.Std.Monad.S2.t
          val forever :
            ('a, 'e) Monads.Std.Monad.S2.t -> ('b, 'e) Monads.Std.Monad.S2.t
          module Fn :
            sig
              val id : '-> ('a, 'e) Monads.Std.Monad.S2.t
              val ignore :
                ('a, 'e) Monads.Std.Monad.S2.t ->
                (unit, 'e) Monads.Std.Monad.S2.t
              val nothing : unit -> (unit, 'e) Monads.Std.Monad.S2.t
              val non :
                ('-> (bool, 'e) Monads.Std.Monad.S2.t) ->
                '-> (bool, 'e) Monads.Std.Monad.S2.t
              val apply_n_times :
                n:int ->
                ('-> ('a, 'e) Monads.Std.Monad.S2.t) ->
                '-> ('a, 'e) Monads.Std.Monad.S2.t
              val compose :
                ('-> ('c, 'e) Monads.Std.Monad.S2.t) ->
                ('-> ('b, 'e) Monads.Std.Monad.S2.t) ->
                '-> ('c, 'e) Monads.Std.Monad.S2.t
            end
          module Pair :
            sig
              val fst :
                ('a * 'b, 'e) Monads.Std.Monad.S2.t ->
                ('a, 'e) Monads.Std.Monad.S2.t
              val snd :
                ('a * 'b, 'e) Monads.Std.Monad.S2.t ->
                ('b, 'e) Monads.Std.Monad.S2.t
            end
          module Triple :
            sig
              val fst :
                ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
                ('a, 'e) Monads.Std.Monad.S2.t
              val snd :
                ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
                ('b, 'e) Monads.Std.Monad.S2.t
              val trd :
                ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
                ('c, 'e) Monads.Std.Monad.S2.t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) Monads.Std.Monad.S2.t
              val unary :
                ('-> 'b) ->
                ('a, 'e) Monads.Std.Monad.S2.t ->
                ('b, 'e) Monads.Std.Monad.S2.t
              val binary :
                ('-> '-> 'c) ->
                ('a, 'e) Monads.Std.Monad.S2.t ->
                ('b, 'e) Monads.Std.Monad.S2.t ->
                ('c, 'e) Monads.Std.Monad.S2.t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) Monads.Std.Monad.S2.t ->
                ('b, 'e) Monads.Std.Monad.S2.t ->
                ('c, 'e) Monads.Std.Monad.S2.t ->
                ('d, 'e) Monads.Std.Monad.S2.t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) Monads.Std.Monad.S2.t ->
                ('b, 's) Monads.Std.Monad.S2.t ->
                ('c, 's) Monads.Std.Monad.S2.t ->
                ('d, 's) Monads.Std.Monad.S2.t ->
                ('e, 's) Monads.Std.Monad.S2.t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) Monads.Std.Monad.S2.t ->
                ('b, 's) Monads.Std.Monad.S2.t ->
                ('c, 's) Monads.Std.Monad.S2.t ->
                ('d, 's) Monads.Std.Monad.S2.t ->
                ('e, 's) Monads.Std.Monad.S2.t ->
                ('f, 's) Monads.Std.Monad.S2.t
            end
          module Exn :
            sig
              val expect :
                ?finally:(unit -> (unit, 's) Monads.Std.Monad.S2.t) ->
                f:(unit -> ('a, 's) Monads.Std.Monad.S2.t) ->
                catch:(exn -> ('a, 's) Monads.Std.Monad.S2.t) ->
                ('a, 's) Monads.Std.Monad.S2.t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter :
                    'a t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'a t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'a t -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('b option, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t -> f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
              val iter :
                'a list ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'a list ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'a list ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
              val exists : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all : 'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
              val find_map :
                'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
              val filter :
                'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
              val filter_map :
                'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
            end
          module Seq :
            sig
              val all :
                ('a, 'e) t Core_kernel.Sequence.t ->
                ('Core_kernel.Sequence.t, 'e) t
              val all_ignore :
                ('a, 'e) t Core_kernel.Sequence.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                (Monoid.Unit.t, 'e) t
              val map :
                'Core_kernel.Sequence.t ->
                f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
              val iter :
                'Core_kernel.Sequence.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Core_kernel.Sequence.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Core_kernel.Sequence.t ->
                f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
              val exists :
                'Core_kernel.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Core_kernel.Sequence.t ->
                f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Core_kernel.Sequence.t ->
                f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Sequence.t ->
                f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Core_kernel.Sequence.t ->
                f:('-> (bool, 'e) t) -> ('a option, 'e) t
              val find_map :
                'Core_kernel.Sequence.t ->
                f:('-> ('b option, 'e) t) -> ('b option, 'e) t
              val filter :
                'Core_kernel.Sequence.t ->
                f:('-> (bool, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
              val filter_map :
                'Core_kernel.Sequence.t ->
                f:('-> ('b option, 'e) t) ->
                ('Core_kernel.Sequence.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_unit : (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          val all_ignore :
            (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
        end
      module type Core = Core_kernel.Monad.S
      module type Core2 = Core_kernel.Monad.S2
      module type Minimal =
        sig
          type 'a t
          val return : '-> 'Monads.Std.Monad.Minimal.t
          val bind :
            'Monads.Std.Monad.Minimal.t ->
            ('-> 'Monads.Std.Monad.Minimal.t) ->
            'Monads.Std.Monad.Minimal.t
        end
      module type Minimal2 =
        sig
          type ('a, 'e) t
          val return : '-> ('a, 'e) Monads.Std.Monad.Minimal2.t
          val bind :
            ('a, 'e) Monads.Std.Monad.Minimal2.t ->
            ('-> ('b, 'e) Monads.Std.Monad.Minimal2.t) ->
            ('b, 'e) Monads.Std.Monad.Minimal2.t
        end
      module Make :
        functor (M : Basic->
          sig
            val void : 'M.t -> Monoid.Unit.t M.t
            val sequence : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
            val forever : 'M.t -> 'M.t
            module Fn :
              sig
                val id : '-> 'M.t
                val ignore : 'M.t -> Monoid.Unit.t M.t
                val nothing : Monoid.Unit.t -> Monoid.Unit.t M.t
                val non : ('-> bool M.t) -> '-> bool M.t
                val apply_n_times :
                  n:Monoid.Int.t -> ('-> 'M.t) -> '-> 'M.t
                val compose :
                  ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
              end
            module Pair :
              sig
                val fst : ('a * 'b) M.t -> 'M.t
                val snd : ('a * 'b) M.t -> 'M.t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) M.t -> 'M.t
                val snd : ('a * 'b * 'c) M.t -> 'M.t
                val trd : ('a * 'b * 'c) M.t -> 'M.t
              end
            module Lift :
              sig
                val nullary : '-> 'M.t
                val unary : ('-> 'b) -> 'M.t -> 'M.t
                val binary : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(Monoid.Unit.t -> Monoid.Unit.t M.t) ->
                  f:(Monoid.Unit.t -> 'M.t) ->
                  catch:(exn -> 'M.t) -> 'M.t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'M.t t -> 'a t M.t
                    val all_ignore : 'M.t t -> Monoid.Unit.t M.t
                    val sequence : Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
                    val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                    val iter :
                      'a t ->
                      f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                    val fold :
                      'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_left :
                      'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_right :
                      'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                    val reduce :
                      'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                    val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                    val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                    val count :
                      'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'M.t) -> 'M.t
                    val find : 'a t -> f:('-> bool M.t) -> 'a option M.t
                    val find_map :
                      'a t -> f:('-> 'b option M.t) -> 'b option M.t
                    val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                    val filter_map :
                      'a t -> f:('-> 'b option M.t) -> 'b t M.t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'M.t T.t -> 'T.t M.t
                      val all_ignore : 'M.t T.t -> Monoid.Unit.t M.t
                      val sequence :
                        Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t
                      val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t
                      val iter :
                        'T.t ->
                        f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                      val fold :
                        'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                      val fold_left :
                        'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                      val fold_right :
                        'T.t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                      val reduce :
                        'T.t -> f:('-> '-> 'M.t) -> 'a option M.t
                      val exists : 'T.t -> f:('-> bool M.t) -> bool M.t
                      val for_all : 'T.t -> f:('-> bool M.t) -> bool M.t
                      val count :
                        'T.t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'M.t) -> 'M.t
                      val find :
                        'T.t -> f:('-> bool M.t) -> 'a option M.t
                      val find_map :
                        'T.t -> f:('-> 'b option M.t) -> 'b option M.t
                      val filter : 'T.t -> f:('-> bool M.t) -> 'T.t M.t
                      val filter_map :
                        'T.t -> f:('-> 'b option M.t) -> 'T.t M.t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'M.t T.t -> 'T.t M.t
                      val all_ignore : 'M.t T.t -> Monoid.Unit.t M.t
                      val sequence :
                        Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t
                      val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t
                      val iter :
                        'T.t ->
                        f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                      val fold :
                        'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                      val fold_left :
                        'T.t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                      val fold_right :
                        'T.t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                      val reduce :
                        'T.t -> f:('-> '-> 'M.t) -> 'a option M.t
                      val exists : 'T.t -> f:('-> bool M.t) -> bool M.t
                      val for_all : 'T.t -> f:('-> bool M.t) -> bool M.t
                      val count :
                        'T.t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'M.t) -> 'M.t
                      val find :
                        'T.t -> f:('-> bool M.t) -> 'a option M.t
                      val find_map :
                        'T.t -> f:('-> 'b option M.t) -> 'b option M.t
                      val filter : 'T.t -> f:('-> bool M.t) -> 'T.t M.t
                      val filter_map :
                        'T.t -> f:('-> 'b option M.t) -> 'T.t M.t
                    end
              end
            module List :
              sig
                val all : 'M.t list -> 'a list M.t
                val all_ignore : 'M.t list -> Monoid.Unit.t M.t
                val sequence : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
                val map : 'a list -> f:('-> 'M.t) -> 'b list M.t
                val iter :
                  'a list -> f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                val fold :
                  'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_left :
                  'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_right :
                  'a list -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                val reduce :
                  'a list -> f:('-> '-> 'M.t) -> 'a option M.t
                val exists : 'a list -> f:('-> bool M.t) -> bool M.t
                val for_all : 'a list -> f:('-> bool M.t) -> bool M.t
                val count : 'a list -> f:('-> bool M.t) -> Monoid.Int.t M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'M.t) -> 'M.t
                val find : 'a list -> f:('-> bool M.t) -> 'a option M.t
                val find_map :
                  'a list -> f:('-> 'b option M.t) -> 'b option M.t
                val filter : 'a list -> f:('-> bool M.t) -> 'a list M.t
                val filter_map :
                  'a list -> f:('-> 'b option M.t) -> 'b list M.t
              end
            module Seq :
              sig
                val all :
                  'M.t Core_kernel.Sequence.t ->
                  'Core_kernel.Sequence.t M.t
                val all_ignore :
                  'M.t Core_kernel.Sequence.t -> Monoid.Unit.t M.t
                val sequence :
                  Monoid.Unit.t M.t Core_kernel.Sequence.t ->
                  Monoid.Unit.t M.t
                val map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'M.t) -> 'Core_kernel.Sequence.t M.t
                val iter :
                  'Core_kernel.Sequence.t ->
                  f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                val fold :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_left :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> 'M.t) -> 'M.t
                val fold_right :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> 'M.t) -> init:'-> 'M.t
                val reduce :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> 'M.t) -> 'a option M.t
                val exists :
                  'Core_kernel.Sequence.t -> f:('-> bool M.t) -> bool M.t
                val for_all :
                  'Core_kernel.Sequence.t -> f:('-> bool M.t) -> bool M.t
                val count :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool M.t) -> Monoid.Int.t M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Sequence.t -> f:('-> 'M.t) -> 'M.t
                val find :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool M.t) -> 'a option M.t
                val find_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b option M.t) -> 'b option M.t
                val filter :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool M.t) -> 'Core_kernel.Sequence.t M.t
                val filter_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b option M.t) -> 'Core_kernel.Sequence.t M.t
              end
            val ( >=> ) : ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
            val ( !! ) : '-> 'M.t
            val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t
            val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
            val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
            val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
            module Monad_infix :
              sig
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
              end
            val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
            val return : '-> 'M.t
            val map : 'M.t -> f:('-> 'b) -> 'M.t
            val join : 'M.t M.t -> 'M.t
            val ignore_m : 'M.t -> Monoid.Unit.t M.t
            val all : 'M.t list -> 'a list M.t
            val all_unit : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
            val all_ignore : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
            module Let_syntax :
              sig
                val return : '-> 'M.t
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                module Let_syntax :
                  sig
                    val return : '-> 'M.t
                    val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                    val map : 'M.t -> f:('-> 'b) -> 'M.t
                    val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                val ( >=> ) :
                  ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
                val ( !! ) : '-> 'M.t
                val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t
                val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
              end
          end
      module Make2 :
        functor (M : Basic2->
          sig
            val void : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
            val sequence :
              (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
            val forever : ('a, 'e) M.t -> ('b, 'e) M.t
            module Fn :
              sig
                val id : '-> ('a, 'e) M.t
                val ignore : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) M.t
                val non : ('-> (bool, 'e) M.t) -> '-> (bool, 'e) M.t
                val apply_n_times :
                  n:Monoid.Int.t ->
                  ('-> ('a, 'e) M.t) -> '-> ('a, 'e) M.t
                val compose :
                  ('-> ('c, 'e) M.t) ->
                  ('-> ('b, 'e) M.t) -> '-> ('c, 'e) M.t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) M.t -> ('a, 'e) M.t
                val snd : ('a * 'b, 'e) M.t -> ('b, 'e) M.t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) M.t -> ('a, 'e) M.t
                val snd : ('a * 'b * 'c, 'e) M.t -> ('b, 'e) M.t
                val trd : ('a * 'b * 'c, 'e) M.t -> ('c, 'e) M.t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) M.t
                val unary : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
                val binary :
                  ('-> '-> 'c) ->
                  ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) M.t ->
                  ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) M.t ->
                  ('b, 's) M.t ->
                  ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) M.t ->
                  ('b, 's) M.t ->
                  ('c, 's) M.t ->
                  ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) M.t) ->
                  f:(Monoid.Unit.t -> ('a, 's) M.t) ->
                  catch:(exn -> ('a, 's) M.t) -> ('a, 's) M.t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                    val all_ignore :
                      ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                    val sequence :
                      (Monoid.Unit.t, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                    val map :
                      'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                    val iter :
                      'a t ->
                      f:('-> (Monoid.Unit.t, 'e) M.t) ->
                      (Monoid.Unit.t, 'e) M.t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                    val exists :
                      'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val for_all :
                      'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                    val find :
                      'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                    val find_map :
                      'a t ->
                      f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                    val filter :
                      'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                    val filter_map :
                      'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t
                      val all_ignore :
                        ('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t
                      val sequence :
                        (Monoid.Unit.t, 'e) M.t T.t ->
                        (Monoid.Unit.t, 'e) M.t
                      val map :
                        'T.t -> f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t
                      val iter :
                        'T.t ->
                        f:('-> (Monoid.Unit.t, 'e) M.t) ->
                        (Monoid.Unit.t, 'e) M.t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) M.t) ->
                        init:'-> ('b, 'e) M.t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                      val exists :
                        'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                      val for_all :
                        'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                      val find_map :
                        'T.t ->
                        f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t
                      val all_ignore :
                        ('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t
                      val sequence :
                        (Monoid.Unit.t, 'e) M.t T.t ->
                        (Monoid.Unit.t, 'e) M.t
                      val map :
                        'T.t -> f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t
                      val iter :
                        'T.t ->
                        f:('-> (Monoid.Unit.t, 'e) M.t) ->
                        (Monoid.Unit.t, 'e) M.t
                      val fold :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                      val fold_left :
                        'T.t ->
                        init:'->
                        f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) M.t) ->
                        init:'-> ('b, 'e) M.t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                      val exists :
                        'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                      val for_all :
                        'T.t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                      val find :
                        'T.t ->
                        f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                      val find_map :
                        'T.t ->
                        f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                      val filter :
                        'T.t ->
                        f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
                val all_ignore : ('a, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
                val sequence :
                  (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
                val map :
                  'a list -> f:('-> ('b, 'e) M.t) -> ('b list, 'e) M.t
                val iter :
                  'a list ->
                  f:('-> (Monoid.Unit.t, 'e) M.t) ->
                  (Monoid.Unit.t, 'e) M.t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                val reduce :
                  'a list ->
                  f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                val exists :
                  'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val for_all :
                  'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val count :
                  'a list ->
                  f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                val find :
                  'a list -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                val find_map :
                  'a list ->
                  f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                val filter :
                  'a list -> f:('-> (bool, 'e) M.t) -> ('a list, 'e) M.t
                val filter_map :
                  'a list ->
                  f:('-> ('b option, 'e) M.t) -> ('b list, 'e) M.t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) M.t Core_kernel.Sequence.t ->
                  ('Core_kernel.Sequence.t, 'e) M.t
                val all_ignore :
                  ('a, 'e) M.t Core_kernel.Sequence.t ->
                  (Monoid.Unit.t, 'e) M.t
                val sequence :
                  (Monoid.Unit.t, 'e) M.t Core_kernel.Sequence.t ->
                  (Monoid.Unit.t, 'e) M.t
                val map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b, 'e) M.t) ->
                  ('Core_kernel.Sequence.t, 'e) M.t
                val iter :
                  'Core_kernel.Sequence.t ->
                  f:('-> (Monoid.Unit.t, 'e) M.t) ->
                  (Monoid.Unit.t, 'e) M.t
                val fold :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_left :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val fold_right :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                val reduce :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                val exists :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val for_all :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                val count :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Sequence.t ->
                  f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                val find :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                val find_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                val filter :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) M.t) ->
                  ('Core_kernel.Sequence.t, 'e) M.t
                val filter_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b option, 'e) M.t) ->
                  ('Core_kernel.Sequence.t, 'e) M.t
              end
            val ( >=> ) :
              ('-> ('b, 'e) M.t) ->
              ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t
            val ( !! ) : '-> ('a, 'e) M.t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
            val ( !$$ ) :
              ('-> '-> 'c) ->
              ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) M.t ->
              ('b, 's) M.t -> ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) M.t ->
              ('b, 's) M.t ->
              ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
            val ( >>= ) :
              ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) M.t
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) M.t
                    val bind :
                      ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                    val both :
                      ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
              end
            val bind : ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
            val return : '-> ('a, 'b) M.t
            val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
            val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
            val ignore_m : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
            val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
            val all_unit :
              (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
            val all_ignore :
              (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
            module Syntax :
              sig
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                val ( >=> ) :
                  ('-> ('b, 'e) M.t) ->
                  ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t
                val ( !! ) : '-> ('a, 'e) M.t
                val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) M.t ->
                  ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) M.t ->
                  ('b, 's) M.t ->
                  ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) M.t ->
                  ('b, 's) M.t ->
                  ('c, 's) M.t ->
                  ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
              end
          end
      module Core :
        functor (M : Core->
          sig
            type 'a t = 'M.t
            val void : 'a t -> Monoid.Unit.t t
            val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
            val forever : 'a t -> 'b t
            module Fn :
              sig
                val id : '-> 'a t
                val ignore : 'a t -> Monoid.Unit.t t
                val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                val non : ('-> bool t) -> '-> bool t
                val apply_n_times :
                  n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
              end
            module Pair :
              sig
                val fst : ('a * 'b) t -> 'a t
                val snd : ('a * 'b) t -> 'b t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) t -> 'a t
                val snd : ('a * 'b * 'c) t -> 'b t
                val trd : ('a * 'b * 'c) t -> 'c t
              end
            module Lift :
              sig
                val nullary : '-> 'a t
                val unary : ('-> 'b) -> 'a t -> 'b t
                val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val ternary :
                  ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                  f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'M.t t -> 'a t M.t
                    val all_ignore : 'M.t t -> Monoid.Unit.t M.t
                    val sequence : Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
                    val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                    val iter :
                      'a t ->
                      f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                    val fold :
                      'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_left :
                      'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_right :
                      'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                    val reduce :
                      'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                    val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                    val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                    val count :
                      'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'M.t) -> 'M.t
                    val find : 'a t -> f:('-> bool M.t) -> 'a option M.t
                    val find_map :
                      'a t -> f:('-> 'b option M.t) -> 'b option M.t
                    val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                    val filter_map :
                      'a t -> f:('-> 'b option M.t) -> 'b t M.t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'a t T.t -> 'T.t t
                      val all_ignore : 'a t T.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                      val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                      val iter :
                        'T.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'T.t -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'T.t -> f:('-> bool t) -> bool t
                      val for_all : 'T.t -> f:('-> bool t) -> bool t
                      val count :
                        'T.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'a t) -> 'a t
                      val find : 'T.t -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'T.t -> f:('-> 'b option t) -> 'b option t
                      val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                      val filter_map :
                        'T.t -> f:('-> 'b option t) -> 'T.t t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'a t T.t -> 'T.t t
                      val all_ignore : 'a t T.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                      val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                      val iter :
                        'T.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'T.t -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'T.t -> f:('-> bool t) -> bool t
                      val for_all : 'T.t -> f:('-> bool t) -> bool t
                      val count :
                        'T.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'a t) -> 'a t
                      val find : 'T.t -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'T.t -> f:('-> 'b option t) -> 'b option t
                      val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                      val filter_map :
                        'T.t -> f:('-> 'b option t) -> 'T.t t
                    end
              end
            module List :
              sig
                val all : 'a t list -> 'a list t
                val all_ignore : 'a t list -> Monoid.Unit.t t
                val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                val map : 'a list -> f:('-> 'b t) -> 'b list t
                val iter :
                  'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
                val exists : 'a list -> f:('-> bool t) -> bool t
                val for_all : 'a list -> f:('-> bool t) -> bool t
                val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'a t) -> 'a t
                val find : 'a list -> f:('-> bool t) -> 'a option t
                val find_map :
                  'a list -> f:('-> 'b option t) -> 'b option t
                val filter : 'a list -> f:('-> bool t) -> 'a list t
                val filter_map :
                  'a list -> f:('-> 'b option t) -> 'b list t
              end
            module Seq :
              sig
                val all :
                  'a t Core_kernel.Sequence.t -> 'Core_kernel.Sequence.t t
                val all_ignore :
                  'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                val sequence :
                  Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                val map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                val iter :
                  'Core_kernel.Sequence.t ->
                  f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                val fold :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> 'a t) -> 'a option t
                val exists :
                  'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                val for_all :
                  'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                val count :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool t) -> Monoid.Int.t t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                val find :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool t) -> 'a option t
                val find_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b option t) -> 'b option t
                val filter :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool t) -> 'Core_kernel.Sequence.t t
                val filter_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b option t) -> 'Core_kernel.Sequence.t t
              end
            val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
            val ( !! ) : '-> 'a t
            val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
            val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            module Monad_infix :
              sig
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              end
            val bind : 'a t -> f:('-> 'b t) -> 'b t
            val return : '-> 'a t
            val map : 'a t -> f:('-> 'b) -> 'b t
            val join : 'a t t -> 'a t
            val ignore_m : 'a t -> Monoid.Unit.t t
            val all : 'a t list -> 'a list t
            val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
            val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
            module Let_syntax :
              sig
                val return : '-> 'a t
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                module Let_syntax :
                  sig
                    val return : '-> 'a t
                    val bind : 'a t -> f:('-> 'b t) -> 'b t
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val both : 'a t -> 'b t -> ('a * 'b) t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                val ( !! ) : '-> 'a t
                val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              end
          end
      module Core2 :
        functor (M : Core2->
          sig
            type ('a, 'e) t = ('a, 'e) M.t
            val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
            val sequence :
              (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
            val forever : ('a, 'e) t -> ('b, 'e) t
            module Fn :
              sig
                val id : '-> ('a, 'e) t
                val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                val apply_n_times :
                  n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                val compose :
                  ('-> ('c, 'e) t) ->
                  ('-> ('b, 'e) t) -> '-> ('c, 'e) t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                val snd : ('a * 'b, 'e) t -> ('b, 'e) t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) t
                val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                val binary :
                  ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) t ->
                  ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) t ->
                  ('b, 's) t ->
                  ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                  f:(Monoid.Unit.t -> ('a, 's) t) ->
                  catch:(exn -> ('a, 's) t) -> ('a, 's) t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                    val all_ignore :
                      ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                    val sequence :
                      (Monoid.Unit.t, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                    val map :
                      'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                    val iter :
                      'a t ->
                      f:('-> (Monoid.Unit.t, 'e) M.t) ->
                      (Monoid.Unit.t, 'e) M.t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                    val exists :
                      'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val for_all :
                      'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                    val find :
                      'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                    val find_map :
                      'a t ->
                      f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                    val filter :
                      'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                    val filter_map :
                      'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                      val iter :
                        'T.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                      val iter :
                        'T.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) t list -> ('a list, 'e) t
                val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                val sequence :
                  (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                val iter :
                  'a list ->
                  f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                val exists :
                  'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count :
                  'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                val find_map :
                  'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                val filter :
                  'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                val filter_map :
                  'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) t Core_kernel.Sequence.t ->
                  ('Core_kernel.Sequence.t, 'e) t
                val all_ignore :
                  ('a, 'e) t Core_kernel.Sequence.t -> (Monoid.Unit.t, 'e) t
                val sequence :
                  (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                  (Monoid.Unit.t, 'e) t
                val map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                val iter :
                  'Core_kernel.Sequence.t ->
                  f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                val fold :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                val exists :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Sequence.t ->
                  f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> ('a option, 'e) t
                val find_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                val filter :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                val filter_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b option, 'e) t) ->
                  ('Core_kernel.Sequence.t, 'e) t
              end
            val ( >=> ) :
              ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
            val ( !! ) : '-> ('a, 'e) t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
            val ( !$$ ) :
              ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) t ->
              ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) t ->
              ('b, 's) t ->
              ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) t
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) t
                    val bind :
                      ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                    val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                    val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              end
            val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
            val return : '-> ('a, 'b) t
            val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
            val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
            val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
            val all : ('a, 'e) t list -> ('a list, 'e) t
            val all_unit :
              (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
            val all_ignore :
              (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
            module Syntax :
              sig
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                val ( >=> ) :
                  ('-> ('b, 'e) t) ->
                  ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                val ( !! ) : '-> ('a, 'e) t
                val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                val ( !$$ ) :
                  ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) t ->
                  ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) t ->
                  ('b, 's) t ->
                  ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              end
          end
      module Minimal :
        functor (M : Minimal->
          sig
            type 'a t = 'M.t
            val void : 'a t -> Monoid.Unit.t t
            val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
            val forever : 'a t -> 'b t
            module Fn :
              sig
                val id : '-> 'a t
                val ignore : 'a t -> Monoid.Unit.t t
                val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                val non : ('-> bool t) -> '-> bool t
                val apply_n_times :
                  n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
              end
            module Pair :
              sig
                val fst : ('a * 'b) t -> 'a t
                val snd : ('a * 'b) t -> 'b t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c) t -> 'a t
                val snd : ('a * 'b * 'c) t -> 'b t
                val trd : ('a * 'b * 'c) t -> 'c t
              end
            module Lift :
              sig
                val nullary : '-> 'a t
                val unary : ('-> 'b) -> 'a t -> 'b t
                val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val ternary :
                  ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                  f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : 'M.t t -> 'a t M.t
                    val all_ignore : 'M.t t -> Monoid.Unit.t M.t
                    val sequence : Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
                    val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                    val iter :
                      'a t ->
                      f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                    val fold :
                      'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_left :
                      'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_right :
                      'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                    val reduce :
                      'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                    val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                    val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                    val count :
                      'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> 'M.t) -> 'M.t
                    val find : 'a t -> f:('-> bool M.t) -> 'a option M.t
                    val find_map :
                      'a t -> f:('-> 'b option M.t) -> 'b option M.t
                    val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                    val filter_map :
                      'a t -> f:('-> 'b option M.t) -> 'b t M.t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : 'a t T.t -> 'T.t t
                      val all_ignore : 'a t T.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                      val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                      val iter :
                        'T.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'T.t -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'T.t -> f:('-> bool t) -> bool t
                      val for_all : 'T.t -> f:('-> bool t) -> bool t
                      val count :
                        'T.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'a t) -> 'a t
                      val find : 'T.t -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'T.t -> f:('-> 'b option t) -> 'b option t
                      val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                      val filter_map :
                        'T.t -> f:('-> 'b option t) -> 'T.t t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : 'a t T.t -> 'T.t t
                      val all_ignore : 'a t T.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                      val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                      val iter :
                        'T.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'T.t -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'T.t -> f:('-> bool t) -> bool t
                      val for_all : 'T.t -> f:('-> bool t) -> bool t
                      val count :
                        'T.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> 'a t) -> 'a t
                      val find : 'T.t -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'T.t -> f:('-> 'b option t) -> 'b option t
                      val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                      val filter_map :
                        'T.t -> f:('-> 'b option t) -> 'T.t t
                    end
              end
            module List :
              sig
                val all : 'a t list -> 'a list t
                val all_ignore : 'a t list -> Monoid.Unit.t t
                val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                val map : 'a list -> f:('-> 'b t) -> 'b list t
                val iter :
                  'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                val fold : 'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
                val exists : 'a list -> f:('-> bool t) -> bool t
                val for_all : 'a list -> f:('-> bool t) -> bool t
                val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> 'a t) -> 'a t
                val find : 'a list -> f:('-> bool t) -> 'a option t
                val find_map :
                  'a list -> f:('-> 'b option t) -> 'b option t
                val filter : 'a list -> f:('-> bool t) -> 'a list t
                val filter_map :
                  'a list -> f:('-> 'b option t) -> 'b list t
              end
            module Seq :
              sig
                val all :
                  'a t Core_kernel.Sequence.t -> 'Core_kernel.Sequence.t t
                val all_ignore :
                  'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                val sequence :
                  Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                val map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                val iter :
                  'Core_kernel.Sequence.t ->
                  f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                val fold :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_left :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> 'b t) -> 'b t
                val fold_right :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> 'b t) -> init:'-> 'b t
                val reduce :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> 'a t) -> 'a option t
                val exists :
                  'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                val for_all :
                  'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                val count :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool t) -> Monoid.Int.t t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                val find :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool t) -> 'a option t
                val find_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b option t) -> 'b option t
                val filter :
                  'Core_kernel.Sequence.t ->
                  f:('-> bool t) -> 'Core_kernel.Sequence.t t
                val filter_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> 'b option t) -> 'Core_kernel.Sequence.t t
              end
            val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
            val ( !! ) : '-> 'a t
            val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
            val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            module Monad_infix :
              sig
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              end
            val bind : 'a t -> f:('-> 'b t) -> 'b t
            val return : '-> 'a t
            val map : 'a t -> f:('-> 'b) -> 'b t
            val join : 'a t t -> 'a t
            val ignore_m : 'a t -> Monoid.Unit.t t
            val all : 'a t list -> 'a list t
            val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
            val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
            module Let_syntax :
              sig
                val return : '-> 'a t
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                module Let_syntax :
                  sig
                    val return : '-> 'a t
                    val bind : 'a t -> f:('-> 'b t) -> 'b t
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val both : 'a t -> 'b t -> ('a * 'b) t
                    module Open_on_rhs : sig  end
                  end
              end
            module Syntax :
              sig
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                val ( !! ) : '-> 'a t
                val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              end
          end
      module Minimal2 :
        functor (M : Minimal2->
          sig
            type ('a, 'e) t = ('a, 'e) M.t
            val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
            val sequence :
              (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
            val forever : ('a, 'e) t -> ('b, 'e) t
            module Fn :
              sig
                val id : '-> ('a, 'e) t
                val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                val apply_n_times :
                  n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                val compose :
                  ('-> ('c, 'e) t) ->
                  ('-> ('b, 'e) t) -> '-> ('c, 'e) t
              end
            module Pair :
              sig
                val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                val snd : ('a * 'b, 'e) t -> ('b, 'e) t
              end
            module Triple :
              sig
                val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
              end
            module Lift :
              sig
                val nullary : '-> ('a, 'e) t
                val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                val binary :
                  ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                val ternary :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                val quaternary :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) t ->
                  ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                val quinary :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) t ->
                  ('b, 's) t ->
                  ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              end
            module Exn :
              sig
                val expect :
                  ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                  f:(Monoid.Unit.t -> ('a, 's) t) ->
                  catch:(exn -> ('a, 's) t) -> ('a, 's) t
              end
            module Collection :
              sig
                module type S =
                  sig
                    type 'a t
                    val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                    val all_ignore :
                      ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                    val sequence :
                      (Monoid.Unit.t, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                    val map :
                      'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                    val iter :
                      'a t ->
                      f:('-> (Monoid.Unit.t, 'e) M.t) ->
                      (Monoid.Unit.t, 'e) M.t
                    val fold :
                      'a t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_left :
                      'a t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_right :
                      'a t ->
                      f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                    val reduce :
                      'a t ->
                      f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                    val exists :
                      'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val for_all :
                      'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val count :
                      'a t ->
                      f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                    val find :
                      'a t -> f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                    val find_map :
                      'a t ->
                      f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                    val filter :
                      'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                    val filter_map :
                      'a t -> f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
                  end
                module Eager :
                  functor (T : Collection.Eager->
                    sig
                      val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                      val iter :
                        'T.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                    end
                module Delay :
                  functor (T : Collection.Delay->
                    sig
                      val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                      val iter :
                        'T.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'T.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'T.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'T.t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'T.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'T.t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                      val filter_map :
                        'T.t ->
                        f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                    end
              end
            module List :
              sig
                val all : ('a, 'e) t list -> ('a list, 'e) t
                val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                val sequence :
                  (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                val map : 'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                val iter :
                  'a list ->
                  f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                val fold :
                  'a list ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'a list ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'a list ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'a list -> f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                val exists :
                  'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count :
                  'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                val find_map :
                  'a list -> f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                val filter :
                  'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                val filter_map :
                  'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
              end
            module Seq :
              sig
                val all :
                  ('a, 'e) t Core_kernel.Sequence.t ->
                  ('Core_kernel.Sequence.t, 'e) t
                val all_ignore :
                  ('a, 'e) t Core_kernel.Sequence.t -> (Monoid.Unit.t, 'e) t
                val sequence :
                  (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                  (Monoid.Unit.t, 'e) t
                val map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                val iter :
                  'Core_kernel.Sequence.t ->
                  f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                val fold :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_left :
                  'Core_kernel.Sequence.t ->
                  init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                val fold_right :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                val reduce :
                  'Core_kernel.Sequence.t ->
                  f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                val exists :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                val for_all :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                val count :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                val map_reduce :
                  (module Monoid.S with type t = 'a) ->
                  'Core_kernel.Sequence.t ->
                  f:('-> ('a, 'e) t) -> ('a, 'e) t
                val find :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> ('a option, 'e) t
                val find_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                val filter :
                  'Core_kernel.Sequence.t ->
                  f:('-> (bool, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                val filter_map :
                  'Core_kernel.Sequence.t ->
                  f:('-> ('b option, 'e) t) ->
                  ('Core_kernel.Sequence.t, 'e) t
              end
            val ( >=> ) :
              ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
            val ( !! ) : '-> ('a, 'e) t
            val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
            val ( !$$ ) :
              ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
            val ( !$$$ ) :
              ('-> '-> '-> 'd) ->
              ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
            val ( !$$$$ ) :
              ('-> '-> '-> '-> 'e) ->
              ('a, 's) t ->
              ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
            val ( !$$$$$ ) :
              ('-> '-> '-> '-> '-> 'f) ->
              ('a, 's) t ->
              ('b, 's) t ->
              ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
            val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            module Let_syntax :
              sig
                val return : '-> ('a, 'b) t
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) t
                    val bind :
                      ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                    val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                    val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                    module Open_on_rhs : sig  end
                  end
              end
            module Monad_infix :
              sig
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              end
            val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
            val return : '-> ('a, 'b) t
            val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
            val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
            val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
            val all : ('a, 'e) t list -> ('a list, 'e) t
            val all_unit :
              (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
            val all_ignore :
              (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
            module Syntax :
              sig
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                val ( >=> ) :
                  ('-> ('b, 'e) t) ->
                  ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                val ( !! ) : '-> ('a, 'e) t
                val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                val ( !$$ ) :
                  ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) t ->
                  ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) t ->
                  ('b, 's) t ->
                  ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              end
          end
      module type Monad = S
      module type Monad2 = S2
      module Ident :
        sig
          type 'a t = 'a
          val void : '-> Monoid.Unit.t
          val sequence : Monoid.Unit.t list -> Monoid.Unit.t
          val forever : '-> 'b
          module Fn :
            sig
              val id : '-> 'a
              val ignore : '-> Monoid.Unit.t
              val nothing : Monoid.Unit.t -> Monoid.Unit.t
              val non : ('-> bool) -> '-> bool
              val apply_n_times : n:Monoid.Int.t -> ('-> 'a) -> '-> 'a
              val compose : ('-> 'c) -> ('-> 'b) -> '-> 'c
            end
          module Pair :
            sig val fst : 'a * '-> 'val snd : 'a * '-> 'end
          module Triple :
            sig
              val fst : 'a * 'b * '-> 'a
              val snd : 'a * 'b * '-> 'b
              val trd : 'a * 'b * '-> 'c
            end
          module Lift :
            sig
              val nullary : '-> 'a
              val unary : ('-> 'b) -> '-> 'b
              val binary : ('-> '-> 'c) -> '-> '-> 'c
              val ternary : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
              val quaternary :
                ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                '-> '-> '-> '-> '-> 'f
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> Monoid.Unit.t) ->
                f:(Monoid.Unit.t -> 'a) -> catch:(exn -> 'a) -> 'a
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a t -> 'a t
                  val all_ignore : 'a t -> Monoid.Unit.t
                  val sequence : Monoid.Unit.t t -> Monoid.Unit.t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val iter : 'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                  val fold : 'a t -> init:'-> f:('-> '-> 'b) -> 'b
                  val fold_left : 'a t -> init:'-> f:('-> '-> 'b) -> 'b
                  val fold_right :
                    'a t -> f:('-> '-> 'b) -> init:'-> 'b
                  val reduce : 'a t -> f:('-> '-> 'a) -> 'a option
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a) -> 'a
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'T.t -> 'T.t
                    val all_ignore : 'T.t -> Monoid.Unit.t
                    val sequence : Monoid.Unit.t T.t -> Monoid.Unit.t
                    val map : 'T.t -> f:('-> 'b) -> 'T.t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                    val fold : 'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                    val fold_right :
                      'T.t -> f:('-> '-> 'b) -> init:'-> 'b
                    val reduce : 'T.t -> f:('-> '-> 'a) -> 'a option
                    val exists : 'T.t -> f:('-> bool) -> bool
                    val for_all : 'T.t -> f:('-> bool) -> bool
                    val count : 'T.t -> f:('-> bool) -> Monoid.Int.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a) -> 'a
                    val find : 'T.t -> f:('-> bool) -> 'a option
                    val find_map : 'T.t -> f:('-> 'b option) -> 'b option
                    val filter : 'T.t -> f:('-> bool) -> 'T.t
                    val filter_map : 'T.t -> f:('-> 'b option) -> 'T.t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'T.t -> 'T.t
                    val all_ignore : 'T.t -> Monoid.Unit.t
                    val sequence : Monoid.Unit.t T.t -> Monoid.Unit.t
                    val map : 'T.t -> f:('-> 'b) -> 'T.t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                    val fold : 'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                    val fold_right :
                      'T.t -> f:('-> '-> 'b) -> init:'-> 'b
                    val reduce : 'T.t -> f:('-> '-> 'a) -> 'a option
                    val exists : 'T.t -> f:('-> bool) -> bool
                    val for_all : 'T.t -> f:('-> bool) -> bool
                    val count : 'T.t -> f:('-> bool) -> Monoid.Int.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a) -> 'a
                    val find : 'T.t -> f:('-> bool) -> 'a option
                    val find_map : 'T.t -> f:('-> 'b option) -> 'b option
                    val filter : 'T.t -> f:('-> bool) -> 'T.t
                    val filter_map : 'T.t -> f:('-> 'b option) -> 'T.t
                  end
            end
          module List :
            sig
              val all : 'a list -> 'a list
              val all_ignore : 'a list -> Monoid.Unit.t
              val sequence : Monoid.Unit.t list -> Monoid.Unit.t
              val map : 'a list -> f:('-> 'b) -> 'b list
              val iter : 'a list -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
              val fold : 'a list -> init:'-> f:('-> '-> 'b) -> 'b
              val fold_left : 'a list -> init:'-> f:('-> '-> 'b) -> 'b
              val fold_right : 'a list -> f:('-> '-> 'b) -> init:'-> 'b
              val reduce : 'a list -> f:('-> '-> 'a) -> 'a option
              val exists : 'a list -> f:('-> bool) -> bool
              val for_all : 'a list -> f:('-> bool) -> bool
              val count : 'a list -> f:('-> bool) -> Monoid.Int.t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a) -> 'a
              val find : 'a list -> f:('-> bool) -> 'a option
              val find_map : 'a list -> f:('-> 'b option) -> 'b option
              val filter : 'a list -> f:('-> bool) -> 'a list
              val filter_map : 'a list -> f:('-> 'b option) -> 'b list
            end
          module Seq :
            sig
              val all :
                'Core_kernel.Sequence.t -> 'Core_kernel.Sequence.t
              val all_ignore : 'Core_kernel.Sequence.t -> Monoid.Unit.t
              val sequence :
                Monoid.Unit.t Core_kernel.Sequence.t -> Monoid.Unit.t
              val map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b) -> 'Core_kernel.Sequence.t
              val iter :
                'Core_kernel.Sequence.t ->
                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
              val fold :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b) -> 'b
              val fold_left :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b) -> 'b
              val fold_right :
                'Core_kernel.Sequence.t ->
                f:('-> '-> 'b) -> init:'-> 'b
              val reduce :
                'Core_kernel.Sequence.t -> f:('-> '-> 'a) -> 'a option
              val exists :
                'Core_kernel.Sequence.t -> f:('-> bool) -> bool
              val for_all :
                'Core_kernel.Sequence.t -> f:('-> bool) -> bool
              val count :
                'Core_kernel.Sequence.t -> f:('-> bool) -> Monoid.Int.t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Sequence.t -> f:('-> 'a) -> 'a
              val find :
                'Core_kernel.Sequence.t -> f:('-> bool) -> 'a option
              val find_map :
                'Core_kernel.Sequence.t -> f:('-> 'b option) -> 'b option
              val filter :
                'Core_kernel.Sequence.t ->
                f:('-> bool) -> 'Core_kernel.Sequence.t
              val filter_map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b option) -> 'Core_kernel.Sequence.t
            end
          val ( >=> ) : ('-> 'b) -> ('-> 'c) -> '-> 'c
          val ( !! ) : '-> 'a
          val ( !$ ) : ('-> 'b) -> '-> 'b
          val ( !$$ ) : ('-> '-> 'c) -> '-> '-> 'c
          val ( !$$$ ) : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            '-> '-> '-> '-> '-> 'f
          val ( >>= ) : '-> ('-> 'b) -> 'b
          val ( >>| ) : '-> ('-> 'b) -> 'b
          module Monad_infix :
            sig
              val ( >>= ) : '-> ('-> 'b) -> 'b
              val ( >>| ) : '-> ('-> 'b) -> 'b
            end
          val bind : '-> f:('-> 'b) -> 'b
          val return : '-> 'a
          val map : '-> f:('-> 'b) -> 'b
          val join : '-> 'a
          val ignore_m : '-> Monoid.Unit.t
          val all : 'a list -> 'a list
          val all_unit : Monoid.Unit.t list -> Monoid.Unit.t
          val all_ignore : Monoid.Unit.t list -> Monoid.Unit.t
          module Let_syntax :
            sig
              val return : '-> 'a
              val ( >>= ) : '-> ('-> 'b) -> 'b
              val ( >>| ) : '-> ('-> 'b) -> 'b
              module Let_syntax :
                sig
                  val return : '-> 'a
                  val bind : '-> f:('-> 'b) -> 'b
                  val map : '-> f:('-> 'b) -> 'b
                  val both : '-> '-> 'a * 'b
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : '-> ('-> 'b) -> 'b
              val ( >>| ) : '-> ('-> 'b) -> 'b
              val ( >=> ) : ('-> 'b) -> ('-> 'c) -> '-> 'c
              val ( !! ) : '-> 'a
              val ( !$ ) : ('-> 'b) -> '-> 'b
              val ( !$$ ) : ('-> '-> 'c) -> '-> '-> 'c
              val ( !$$$ ) : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                '-> '-> '-> '-> '-> 'f
            end
        end
      module Option :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'a t -> f:('-> 'b option t) -> 'b option t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'b option t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'a option t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find : 'T.t -> f:('-> bool t) -> 'a option t
                        val find_map :
                          'T.t -> f:('-> 'b option t) -> 'b option t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'b option t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'a option t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find : 'T.t -> f:('-> bool t) -> 'a option t
                        val find_map :
                          'T.t -> f:('-> 'b option t) -> 'b option t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'b option t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t list -> 'a list t
                  val all_ignore : 'a t list -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val map : 'a list -> f:('-> 'b t) -> 'b list t
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'a list -> f:('-> bool t) -> bool t
                  val for_all : 'a list -> f:('-> bool t) -> bool t
                  val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a t) -> 'a t
                  val find : 'a list -> f:('-> bool t) -> 'a option t
                  val find_map :
                    'a list -> f:('-> 'b option t) -> 'b option t
                  val filter : 'a list -> f:('-> bool t) -> 'a list t
                  val filter_map :
                    'a list -> f:('-> 'b option t) -> 'b list t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Sequence.t ->
                    'Core_kernel.Sequence.t t
                  val all_ignore :
                    'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val sequence :
                    Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'a t) -> 'a option t
                  val exists :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'a option t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b option t) -> 'b option t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Sequence.t t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b option t) -> 'Core_kernel.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              val pure : '-> 'a t
              val accept : '-> 'a t
              val reject : Monoid.Unit.t -> 'a t
              val guard : bool -> Monoid.Unit.t t
              val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
              val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
              val zero : Monoid.Unit.t -> 'a t
              val plus : 'a t -> 'a t -> 'a t
              type 'a error = Monoid.Unit.t
              val fail : Monoid.Unit.t -> 'a t
              val catch : 'a t -> (Monoid.Unit.t -> 'a t) -> 'a t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type ('a, 'e) m
              type ('a, 'e) e
              val lift : ('a, 'e) m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('b option, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('a option, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('a option, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val map :
                    'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                  val iter :
                    'a list ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a list ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a list ->
                    f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'a list ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                  val filter_map :
                    'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
                end
              module Seq :
                sig
                  val all :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val all_ignore :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t ->
                    f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('b option, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val pure : '-> ('a, 'e) t
              val accept : '-> ('a, 'e) t
              val reject : Monoid.Unit.t -> ('a, 'e) t
              val guard : bool -> (Monoid.Unit.t, 'e) t
              val on : bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
              val unless :
                bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
              val zero : Monoid.Unit.t -> ('a, 'e) t
              val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
              type 'a error = Monoid.Unit.t
              val fail : Monoid.Unit.t -> ('a, 'e) t
              val catch :
                ('a, 'e) t -> (Monoid.Unit.t -> ('a, 'e) t) -> ('a, 'e) t
            end
          type 'a t = 'a option
          type 'a m = 'a
          type 'a e = 'a t
          val lift : '-> 'a e
          val run : 'a e -> 'a e
          val void : 'a e -> Monoid.Unit.t e
          val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
          val forever : 'a e -> 'b e
          module Fn :
            sig
              val id : '-> 'a e
              val ignore : 'a e -> Monoid.Unit.t e
              val nothing : Monoid.Unit.t -> Monoid.Unit.t e
              val non : ('-> bool e) -> '-> bool e
              val apply_n_times :
                n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
              val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
            end
          module Pair :
            sig
              val fst : ('a * 'b) e -> 'a e
              val snd : ('a * 'b) e -> 'b e
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) e -> 'a e
              val snd : ('a * 'b * 'c) e -> 'b e
              val trd : ('a * 'b * 'c) e -> 'c e
            end
          module Lift :
            sig
              val nullary : '-> 'a e
              val unary : ('-> 'b) -> 'a e -> 'b e
              val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ternary :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a e t -> 'a t e
                  val all_ignore : 'a e t -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                  val map : 'a t -> f:('-> 'b e) -> 'b t e
                  val iter :
                    'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a t -> f:('-> '-> 'a e) -> 'a e e
                  val exists : 'a t -> f:('-> bool e) -> bool e
                  val for_all : 'a t -> f:('-> bool e) -> bool e
                  val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a e) -> 'a e
                  val find : 'a t -> f:('-> bool e) -> 'a e e
                  val find_map : 'a t -> f:('-> 'b e e) -> 'b e e
                  val filter : 'a t -> f:('-> bool e) -> 'a t e
                  val filter_map : 'a t -> f:('-> 'b e e) -> 'b t e
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> Monoid.Unit.t e
                    val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce : 'T.t -> f:('-> '-> 'a e) -> 'a e e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> Monoid.Int.t e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'a e e
                    val find_map : 'T.t -> f:('-> 'b e e) -> 'b e e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map : 'T.t -> f:('-> 'b e e) -> 'T.t e
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> Monoid.Unit.t e
                    val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce : 'T.t -> f:('-> '-> 'a e) -> 'a e e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> Monoid.Int.t e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'a e e
                    val find_map : 'T.t -> f:('-> 'b e e) -> 'b e e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map : 'T.t -> f:('-> 'b e e) -> 'T.t e
                  end
            end
          module List :
            sig
              val all : 'a e list -> 'a list e
              val all_ignore : 'a e list -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
              val map : 'a list -> f:('-> 'b e) -> 'b list e
              val iter :
                'a list -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
              val fold : 'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left :
                'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a list -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a list -> f:('-> '-> 'a e) -> 'a e e
              val exists : 'a list -> f:('-> bool e) -> bool e
              val for_all : 'a list -> f:('-> bool e) -> bool e
              val count : 'a list -> f:('-> bool e) -> Monoid.Int.t e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b list -> f:('-> 'a e) -> 'a e
              val find : 'a list -> f:('-> bool e) -> 'a e e
              val find_map : 'a list -> f:('-> 'b e e) -> 'b e e
              val filter : 'a list -> f:('-> bool e) -> 'a list e
              val filter_map : 'a list -> f:('-> 'b e e) -> 'b list e
            end
          module Seq :
            sig
              val all :
                'a e Core_kernel.Sequence.t -> 'Core_kernel.Sequence.t e
              val all_ignore : 'a e Core_kernel.Sequence.t -> Monoid.Unit.t e
              val sequence :
                Monoid.Unit.t e Core_kernel.Sequence.t -> Monoid.Unit.t e
              val map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b e) -> 'Core_kernel.Sequence.t e
              val iter :
                'Core_kernel.Sequence.t ->
                f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
              val fold :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'Core_kernel.Sequence.t ->
                f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce :
                'Core_kernel.Sequence.t -> f:('-> '-> 'a e) -> 'a e e
              val exists :
                'Core_kernel.Sequence.t -> f:('-> bool e) -> bool e
              val for_all :
                'Core_kernel.Sequence.t -> f:('-> bool e) -> bool e
              val count :
                'Core_kernel.Sequence.t ->
                f:('-> bool e) -> Monoid.Int.t e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Sequence.t -> f:('-> 'a e) -> 'a e
              val find :
                'Core_kernel.Sequence.t -> f:('-> bool e) -> 'a e e
              val find_map :
                'Core_kernel.Sequence.t -> f:('-> 'b e e) -> 'b e e
              val filter :
                'Core_kernel.Sequence.t ->
                f:('-> bool e) -> 'Core_kernel.Sequence.t e
              val filter_map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b e e) -> 'Core_kernel.Sequence.t e
            end
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Monad_infix :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
            end
          val bind : 'a e -> f:('-> 'b e) -> 'b e
          val return : '-> 'a e
          val map : 'a e -> f:('-> 'b) -> 'b e
          val join : 'a e e -> 'a e
          val ignore_m : 'a e -> Monoid.Unit.t e
          val all : 'a e list -> 'a list e
          val all_unit : Monoid.Unit.t e list -> Monoid.Unit.t e
          val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val bind : 'a e -> f:('-> 'b e) -> 'b e
                  val map : 'a e -> f:('-> 'b) -> 'b e
                  val both : 'a e -> 'b e -> ('a * 'b) e
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          val pure : '-> 'a e
          val accept : '-> 'a e
          val reject : Monoid.Unit.t -> 'a e
          val guard : bool -> Monoid.Unit.t e
          val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
          val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
          val zero : Monoid.Unit.t -> 'a e
          val plus : 'a e -> 'a e -> 'a e
          type 'a error = Monoid.Unit.t
          val fail : Monoid.Unit.t -> 'a e
          val catch : 'a e -> (Monoid.Unit.t -> 'a e) -> 'a e
          module T1 :
            functor (M : Core_kernel.T1->
              sig
                type 'a t = 'a e M.t
                type 'a m = 'M.t
                type 'a e = 'Monads.Std.Monad.Option.T1.t
              end
          module T2 :
            functor (M : Core_kernel.T2->
              sig
                type ('a, 'e) t = ('a e, 'e) M.t
                type ('a, 'e) m = ('a, 'e) M.t
                type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Option.T2.t
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T1(M).t
                val run : 'T1(M).t -> 'Monads.Std.Monad.Option.T1.t
                val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val sequence :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val forever : 'T1(M).t -> 'T1(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(M).t
                    val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                    val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val compose :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(M).t
                    val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(M).t) ->
                      catch:(exn -> 'T1(M).t) -> 'T1(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(M).t t -> 'a t T1(M).t
                        val all_ignore :
                          'T1(M).t t -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t t -> Monoid.Unit.t T1(M).t
                        val map :
                          'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a t -> f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                        val exists :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                        val find_map :
                          'a t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                        val filter :
                          'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                        val filter_map :
                          'a t -> f:('-> 'b e T1(M).t) -> 'b t T1(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                          val find_map :
                            'T.t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'b e T1(M).t) -> 'T.t T1(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                          val find_map :
                            'T.t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'b e T1(M).t) -> 'T.t T1(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore : 'T1(M).t list -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val map :
                      'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a list -> f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                    val exists :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a list -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                    val find_map :
                      'a list -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                    val filter :
                      'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                    val filter_map :
                      'a list -> f:('-> 'b e T1(M).t) -> 'b list T1(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(M).t
                    val all_ignore :
                      'T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> 'a e T1(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'b e T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                  end
                val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                val return : '-> 'T1(M).t
                val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                val join : 'T1(M).t T1(M).t -> 'T1(M).t
                val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_unit :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val all_ignore :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val bind :
                          'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                        val both :
                          'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                val pure : '-> 'T1(M).t
                val accept : '-> 'T1(M).t
                val reject : Monoid.Unit.t -> 'T1(M).t
                val guard : bool -> Monoid.Unit.t T1(M).t
                val on :
                  bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                val unless :
                  bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                val zero : Monoid.Unit.t -> 'T1(M).t
                val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                type 'a error = Monoid.Unit.t
                val fail : Monoid.Unit.t -> 'T1(M).t
                val catch :
                  'T1(M).t -> (Monoid.Unit.t -> 'T1(M).t) -> 'T1(M).t
              end
          module Make2 :
            functor (M : Monad2->
              sig
                val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                val run :
                  ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Option.T2.t
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('a e, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('b e, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('a e, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('a e, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('b e, 'e) T2(M).t) ->
                            ('b e, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b e, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('a e, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('a e, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('b e, 'e) T2(M).t) ->
                            ('b e, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b e, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('b e, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b e, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                val pure : '-> ('a, 'e) T2(M).t
                val accept : '-> ('a, 'e) T2(M).t
                val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
                val on :
                  bool ->
                  (Monoid.Unit.t, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val unless :
                  bool ->
                  (Monoid.Unit.t, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val plus :
                  ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
                type 'a error = Monoid.Unit.t
                val fail : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val catch :
                  ('a, 'e) T2(M).t ->
                  (Monoid.Unit.t -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
              end
        end
      module Result :
        sig
          type ('a, 'e) result =
            ('a, 'e) Core_kernel.Result.t =
              Ok of 'a
            | Error of 'e
          module type S =
            sig
              type err
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t list -> 'a list t
                  val all_ignore : 'a t list -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val map : 'a list -> f:('-> 'b t) -> 'b list t
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'a list -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a list -> f:('-> bool t) -> bool t
                  val for_all : 'a list -> f:('-> bool t) -> bool t
                  val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a t) -> 'a t
                  val find : 'a list -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a list -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a list -> f:('-> bool t) -> 'a list t
                  val filter_map :
                    'a list -> f:('-> 'Option.t t) -> 'b list t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Sequence.t ->
                    'Core_kernel.Sequence.t t
                  val all_ignore :
                    'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val sequence :
                    Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'a t) -> 'Option.t t
                  val exists :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Option.t t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Sequence.t t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Core_kernel.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              type 'a error = err
              val fail : err -> 'a t
              val catch : 'a t -> (err -> 'a t) -> 'a t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type 'a m
              type ('a, 'e) e
              val lift : 'a m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val map :
                    'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                  val iter :
                    'a list ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a list ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a list ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a list -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a list ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                  val filter_map :
                    'a list ->
                    f:('-> ('Option.t, 'e) t) -> ('b list, 'e) t
                end
              module Seq :
                sig
                  val all :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val all_ignore :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t ->
                    f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('Option.t, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              type 'a error = 'a
              val fail : '-> ('a, 'e) t
              val catch : ('a, 'e) t -> ('-> ('a, 'e) t) -> ('a, 'e) t
            end
          module T1 :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                type error = T.t
                type 'a m = 'M.t
                type 'a t =
                    ('a, Monads.Std.Monad.Result.T1.error)
                    Monads.Std.Monad.Result.result
                    Monads.Std.Monad.Result.T1.m
                type 'a e =
                    ('a, Monads.Std.Monad.Result.T1.error)
                    Monads.Std.Monad.Result.result
                    Monads.Std.Monad.Result.T1.m
              end
          module T2 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type ('a, 'e) t =
                    ('a, 'e) Monads.Std.Monad.Result.result
                    Monads.Std.Monad.Result.T2.m
                type ('a, 'e) e =
                    ('a, 'e) Monads.Std.Monad.Result.result
                    Monads.Std.Monad.Result.T2.m
              end
          module Make :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                val lift : 'M.t -> 'T1(T)(M).t
                val run : 'T1(T)(M).t -> 'T1(T)(M).e
                val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val sequence :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(T)(M).t
                    val ignore : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                    val non :
                      ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val compose :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(T)(M).t
                    val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                      catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'a list ->
                      f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                  end
                val bind :
                  'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val return : '-> 'T1(T)(M).t
                val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_unit :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val all_ignore :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val both :
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                type 'a error = T.t
                val fail : T.t -> 'T1(T)(M).t
                val catch :
                  'T1(T)(M).t -> (T.t -> 'T1(T)(M).t) -> 'T1(T)(M).t
              end
          module Make2 :
            functor (M : Monad->
              sig
                val lift : 'M.t -> ('a, 'e) T2(M).t
                val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                type 'a error = 'a
                val fail : '-> ('a, 'e) T2(M).t
                val catch :
                  ('a, 'e) T2(M).t ->
                  ('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
              end
          module Error :
            sig
              module type S =
                sig
                  type err
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t list -> 'a list t
                      val all_ignore : 'a t list -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                      val map : 'a list -> f:('-> 'b t) -> 'b list t
                      val iter :
                        'a list ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a list -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a list -> f:('-> bool t) -> bool t
                      val for_all : 'a list -> f:('-> bool t) -> bool t
                      val count :
                        'a list -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> 'a t) -> 'a t
                      val find : 'a list -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a list -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a list -> f:('-> bool t) -> 'a list t
                      val filter_map :
                        'a list -> f:('-> 'Option.t t) -> 'b list t
                    end
                  module Seq :
                    sig
                      val all :
                        'a t Core_kernel.Sequence.t ->
                        'Core_kernel.Sequence.t t
                      val all_ignore :
                        'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t Core_kernel.Sequence.t ->
                        Monoid.Unit.t t
                      val map :
                        'Core_kernel.Sequence.t ->
                        f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                      val iter :
                        'Core_kernel.Sequence.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Core_kernel.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Core_kernel.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Core_kernel.Sequence.t ->
                        f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Core_kernel.Sequence.t ->
                        f:('-> '-> 'a t) -> 'Option.t t
                      val exists :
                        'Core_kernel.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val for_all :
                        'Core_kernel.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val count :
                        'Core_kernel.Sequence.t ->
                        f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Core_kernel.Sequence.t ->
                        f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Core_kernel.Sequence.t ->
                        f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'Core_kernel.Sequence.t ->
                        f:('-> bool t) -> 'Core_kernel.Sequence.t t
                      val filter_map :
                        'Core_kernel.Sequence.t ->
                        f:('-> 'Option.t t) ->
                        'Core_kernel.Sequence.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  type 'a error = err
                  val fail : err -> 'a t
                  val catch : 'a t -> (err -> 'a t) -> 'a t
                  val failf :
                    ('a, Stdlib.Format.formatter, unit, unit -> 'b t)
                    Core_kernel.format4 -> 'a
                end
              module T :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type 'a t =
                        'Core_kernel.Or_error.t
                        Monads.Std.Monad.Result.Error.T.m
                    type 'a e =
                        'Core_kernel.Or_error.t
                        Monads.Std.Monad.Result.Error.T.m
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T(M).t
                    val run : 'T(M).t -> 'T(M).e
                    val void : 'T(M).t -> Monoid.Unit.t T(M).t
                    val sequence :
                      Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                    val forever : 'T(M).t -> 'T(M).t
                    module Fn :
                      sig
                        val id : '-> 'T(M).t
                        val ignore : 'T(M).t -> Monoid.Unit.t T(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T(M).t
                        val non : ('-> bool T(M).t) -> '-> bool T(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                        val compose :
                          ('-> 'T(M).t) ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T(M).t -> 'T(M).t
                        val snd : ('a * 'b) T(M).t -> 'T(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T(M).t -> 'T(M).t
                        val snd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                        val trd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T(M).t
                        val unary : ('-> 'b) -> 'T(M).t -> 'T(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T(M).t ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T(M).t) ->
                          f:(Monoid.Unit.t -> 'T(M).t) ->
                          catch:(exn -> 'T(M).t) -> 'T(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T(M).t t -> 'a t T(M).t
                            val all_ignore :
                              'T(M).t t -> Monoid.Unit.t T(M).t
                            val sequence :
                              Monoid.Unit.t T(M).t t -> Monoid.Unit.t T(M).t
                            val map :
                              'a t -> f:('-> 'T(M).t) -> 'b t T(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T(M).t) ->
                              Monoid.Unit.t T(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T(M).t) ->
                              init:'-> 'T(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                            val exists :
                              'a t -> f:('-> bool T(M).t) -> bool T(M).t
                            val for_all :
                              'a t -> f:('-> bool T(M).t) -> bool T(M).t
                            val count :
                              'a t ->
                              f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T(M).t) -> 'T(M).t
                            val find :
                              'a t ->
                              f:('-> bool T(M).t) -> 'Option.t T(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T(M).t) ->
                              'Option.t T(M).t
                            val filter :
                              'a t -> f:('-> bool T(M).t) -> 'a t T(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T(M).t) -> 'b t T(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T(M).t T.t -> 'T.t T(M).t
                              val all_ignore :
                                'T(M).t T.t -> Monoid.Unit.t T(M).t
                              val sequence :
                                Monoid.Unit.t T(M).t T.t ->
                                Monoid.Unit.t T(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T(M).t) -> 'T.t T(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T(M).t) ->
                                Monoid.Unit.t T(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                init:'-> 'T(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                'Option.t T(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'Option.t T(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) ->
                                'Option.t T(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'T.t T(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T(M).t T.t -> 'T.t T(M).t
                              val all_ignore :
                                'T(M).t T.t -> Monoid.Unit.t T(M).t
                              val sequence :
                                Monoid.Unit.t T(M).t T.t ->
                                Monoid.Unit.t T(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T(M).t) -> 'T.t T(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T(M).t) ->
                                Monoid.Unit.t T(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                init:'-> 'T(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                'Option.t T(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'Option.t T(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) ->
                                'Option.t T(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'T.t T(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T(M).t list -> 'a list T(M).t
                        val all_ignore :
                          'T(M).t list -> Monoid.Unit.t T(M).t
                        val sequence :
                          Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                        val map :
                          'a list -> f:('-> 'T(M).t) -> 'b list T(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T(M).t) ->
                          Monoid.Unit.t T(M).t
                        val fold :
                          'a list ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_left :
                          'a list ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                        val exists :
                          'a list -> f:('-> bool T(M).t) -> bool T(M).t
                        val for_all :
                          'a list -> f:('-> bool T(M).t) -> bool T(M).t
                        val count :
                          'a list ->
                          f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T(M).t) -> 'T(M).t
                        val find :
                          'a list ->
                          f:('-> bool T(M).t) -> 'Option.t T(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                        val filter :
                          'a list -> f:('-> bool T(M).t) -> 'a list T(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T(M).t) -> 'b list T(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T(M).t Core_kernel.Sequence.t ->
                          'Core_kernel.Sequence.t T(M).t
                        val all_ignore :
                          'T(M).t Core_kernel.Sequence.t ->
                          Monoid.Unit.t T(M).t
                        val sequence :
                          Monoid.Unit.t T(M).t Core_kernel.Sequence.t ->
                          Monoid.Unit.t T(M).t
                        val map :
                          'Core_kernel.Sequence.t ->
                          f:('-> 'T(M).t) ->
                          'Core_kernel.Sequence.t T(M).t
                        val iter :
                          'Core_kernel.Sequence.t ->
                          f:('-> Monoid.Unit.t T(M).t) ->
                          Monoid.Unit.t T(M).t
                        val fold :
                          'Core_kernel.Sequence.t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_left :
                          'Core_kernel.Sequence.t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_right :
                          'Core_kernel.Sequence.t ->
                          f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                        val reduce :
                          'Core_kernel.Sequence.t ->
                          f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                        val exists :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> bool T(M).t
                        val for_all :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> bool T(M).t
                        val count :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Sequence.t ->
                          f:('-> 'T(M).t) -> 'T(M).t
                        val find :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> 'Option.t T(M).t
                        val find_map :
                          'Core_kernel.Sequence.t ->
                          f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                        val filter :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) ->
                          'Core_kernel.Sequence.t T(M).t
                        val filter_map :
                          'Core_kernel.Sequence.t ->
                          f:('-> 'Option.t T(M).t) ->
                          'Core_kernel.Sequence.t T(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T(M).t) ->
                      ('-> 'T(M).t) -> '-> 'T(M).t
                    val ( !! ) : '-> 'T(M).t
                    val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T(M).t ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                      end
                    val bind : 'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                    val return : '-> 'T(M).t
                    val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                    val join : 'T(M).t T(M).t -> 'T(M).t
                    val ignore_m : 'T(M).t -> Monoid.Unit.t T(M).t
                    val all : 'T(M).t list -> 'a list T(M).t
                    val all_unit :
                      Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                    val all_ignore :
                      Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T(M).t
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T(M).t
                            val bind :
                              'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                            val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                            val both :
                              'T(M).t -> 'T(M).t -> ('a * 'b) T(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                        val ( >=> ) :
                          ('-> 'T(M).t) ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                        val ( !! ) : '-> 'T(M).t
                        val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T(M).t ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                      end
                    type 'a error = Core_kernel.Error.t
                    val fail : Core_kernel.Error.t -> 'T(M).t
                    val catch :
                      'T(M).t ->
                      (Core_kernel.Error.t -> 'T(M).t) -> 'T(M).t
                    val failf :
                      ('a, Format.formatter, Monoid.Unit.t,
                       Monoid.Unit.t -> 'T(M).t)
                      Core_kernel.format4 -> 'a
                  end
              type 'a t = 'Core_kernel.Or_error.t
              type 'a m = 'a
              type 'a e = 'a t
              val lift : '-> 'a e
              val run : 'a e -> 'a e
              val void : 'a e -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
              val forever : 'a e -> 'b e
              module Fn :
                sig
                  val id : '-> 'a e
                  val ignore : 'a e -> Monoid.Unit.t e
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t e
                  val non : ('-> bool e) -> '-> bool e
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
                  val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
                end
              module Pair :
                sig
                  val fst : ('a * 'b) e -> 'a e
                  val snd : ('a * 'b) e -> 'b e
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) e -> 'a e
                  val snd : ('a * 'b * 'c) e -> 'b e
                  val trd : ('a * 'b * 'c) e -> 'c e
                end
              module Lift :
                sig
                  val nullary : '-> 'a e
                  val unary : ('-> 'b) -> 'a e -> 'b e
                  val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                    f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a e t -> 'a t e
                      val all_ignore : 'a e t -> Monoid.Unit.t e
                      val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                      val map : 'a t -> f:('-> 'b e) -> 'b t e
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_right :
                        'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                      val reduce :
                        'a t -> f:('-> '-> 'a e) -> 'Option.t e
                      val exists : 'a t -> f:('-> bool e) -> bool e
                      val for_all : 'a t -> f:('-> bool e) -> bool e
                      val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a e) -> 'a e
                      val find : 'a t -> f:('-> bool e) -> 'Option.t e
                      val find_map :
                        'a t -> f:('-> 'Option.t e) -> 'Option.t e
                      val filter : 'a t -> f:('-> bool e) -> 'a t e
                      val filter_map :
                        'a t -> f:('-> 'Option.t e) -> 'b t e
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce :
                          'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find :
                          'T.t -> f:('-> bool e) -> 'Option.t e
                        val find_map :
                          'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'Option.t e) -> 'T.t e
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce :
                          'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find :
                          'T.t -> f:('-> bool e) -> 'Option.t e
                        val find_map :
                          'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'Option.t e) -> 'T.t e
                      end
                end
              module List :
                sig
                  val all : 'a e list -> 'a list e
                  val all_ignore : 'a e list -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
                  val map : 'a list -> f:('-> 'b e) -> 'b list e
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a list -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce :
                    'a list -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'a list -> f:('-> bool e) -> bool e
                  val for_all : 'a list -> f:('-> bool e) -> bool e
                  val count : 'a list -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a e) -> 'a e
                  val find : 'a list -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'a list -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'a list -> f:('-> bool e) -> 'a list e
                  val filter_map :
                    'a list -> f:('-> 'Option.t e) -> 'b list e
                end
              module Seq :
                sig
                  val all :
                    'a e Core_kernel.Sequence.t ->
                    'Core_kernel.Sequence.t e
                  val all_ignore :
                    'a e Core_kernel.Sequence.t -> Monoid.Unit.t e
                  val sequence :
                    Monoid.Unit.t e Core_kernel.Sequence.t -> Monoid.Unit.t e
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b e) -> 'Core_kernel.Sequence.t e
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'a e) -> 'Option.t e
                  val exists :
                    'Core_kernel.Sequence.t -> f:('-> bool e) -> bool e
                  val for_all :
                    'Core_kernel.Sequence.t -> f:('-> bool e) -> bool e
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t -> f:('-> 'a e) -> 'a e
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t e) -> 'Option.t e
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool e) -> 'Core_kernel.Sequence.t e
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t e) -> 'Core_kernel.Sequence.t e
                end
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Monad_infix :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                end
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val return : '-> 'a e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val join : 'a e e -> 'a e
              val ignore_m : 'a e -> Monoid.Unit.t e
              val all : 'a e list -> 'a list e
              val all_unit : Monoid.Unit.t e list -> Monoid.Unit.t e
              val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  module Let_syntax :
                    sig
                      val return : '-> 'a e
                      val bind : 'a e -> f:('-> 'b e) -> 'b e
                      val map : 'a e -> f:('-> 'b) -> 'b e
                      val both : 'a e -> 'b e -> ('a * 'b) e
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
                  val ( !! ) : '-> 'a e
                  val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
                  val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              type 'a error = Core_kernel.Error.t
              val fail : Core_kernel.Error.t -> 'a e
              val catch : 'a e -> (Core_kernel.Error.t -> 'a e) -> 'a e
              val failf :
                ('a, Format.formatter, Monoid.Unit.t, Monoid.Unit.t -> 'b e)
                Core_kernel.format4 -> 'a
            end
          module Exception :
            sig
              type 'a t = ('a, exn) Core_kernel.Result.t
              type 'a m = 'a
              type 'a e = ('a, exn) Core_kernel.Result.t
              val lift : '-> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t list -> 'a list t
                  val all_ignore : 'a t list -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val map : 'a list -> f:('-> 'b t) -> 'b list t
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'a list -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a list -> f:('-> bool t) -> bool t
                  val for_all : 'a list -> f:('-> bool t) -> bool t
                  val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a t) -> 'a t
                  val find : 'a list -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a list -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a list -> f:('-> bool t) -> 'a list t
                  val filter_map :
                    'a list -> f:('-> 'Option.t t) -> 'b list t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Sequence.t ->
                    'Core_kernel.Sequence.t t
                  val all_ignore :
                    'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val sequence :
                    Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'a t) -> 'Option.t t
                  val exists :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Option.t t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Sequence.t t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Core_kernel.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              type 'a error = exn
              val fail : exn -> 'a t
              val catch : 'a t -> (exn -> 'a t) -> 'a t
              module T :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type 'a t =
                        ('a, exn) Core_kernel.Result.t
                        Monads.Std.Monad.Result.Exception.T.m
                    type 'a e =
                        ('a, exn) Core_kernel.Result.t
                        Monads.Std.Monad.Result.Exception.T.m
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T(M).t
                    val run : 'T(M).t -> 'T(M).e
                    val void : 'T(M).t -> Monoid.Unit.t T(M).t
                    val sequence :
                      Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                    val forever : 'T(M).t -> 'T(M).t
                    module Fn :
                      sig
                        val id : '-> 'T(M).t
                        val ignore : 'T(M).t -> Monoid.Unit.t T(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T(M).t
                        val non : ('-> bool T(M).t) -> '-> bool T(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                        val compose :
                          ('-> 'T(M).t) ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T(M).t -> 'T(M).t
                        val snd : ('a * 'b) T(M).t -> 'T(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T(M).t -> 'T(M).t
                        val snd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                        val trd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T(M).t
                        val unary : ('-> 'b) -> 'T(M).t -> 'T(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T(M).t ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T(M).t) ->
                          f:(Monoid.Unit.t -> 'T(M).t) ->
                          catch:(exn -> 'T(M).t) -> 'T(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T(M).t t -> 'a t T(M).t
                            val all_ignore :
                              'T(M).t t -> Monoid.Unit.t T(M).t
                            val sequence :
                              Monoid.Unit.t T(M).t t -> Monoid.Unit.t T(M).t
                            val map :
                              'a t -> f:('-> 'T(M).t) -> 'b t T(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T(M).t) ->
                              Monoid.Unit.t T(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T(M).t) ->
                              init:'-> 'T(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                            val exists :
                              'a t -> f:('-> bool T(M).t) -> bool T(M).t
                            val for_all :
                              'a t -> f:('-> bool T(M).t) -> bool T(M).t
                            val count :
                              'a t ->
                              f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T(M).t) -> 'T(M).t
                            val find :
                              'a t ->
                              f:('-> bool T(M).t) -> 'Option.t T(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T(M).t) ->
                              'Option.t T(M).t
                            val filter :
                              'a t -> f:('-> bool T(M).t) -> 'a t T(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T(M).t) -> 'b t T(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T(M).t T.t -> 'T.t T(M).t
                              val all_ignore :
                                'T(M).t T.t -> Monoid.Unit.t T(M).t
                              val sequence :
                                Monoid.Unit.t T(M).t T.t ->
                                Monoid.Unit.t T(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T(M).t) -> 'T.t T(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T(M).t) ->
                                Monoid.Unit.t T(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                init:'-> 'T(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                'Option.t T(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'Option.t T(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) ->
                                'Option.t T(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'T.t T(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T(M).t T.t -> 'T.t T(M).t
                              val all_ignore :
                                'T(M).t T.t -> Monoid.Unit.t T(M).t
                              val sequence :
                                Monoid.Unit.t T(M).t T.t ->
                                Monoid.Unit.t T(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T(M).t) -> 'T.t T(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T(M).t) ->
                                Monoid.Unit.t T(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T(M).t) -> 'T(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                init:'-> 'T(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T(M).t) ->
                                'Option.t T(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T(M).t) -> bool T(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T(M).t) -> 'T(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'Option.t T(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) ->
                                'Option.t T(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T(M).t) -> 'T.t T(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T(M).t) -> 'T.t T(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T(M).t list -> 'a list T(M).t
                        val all_ignore :
                          'T(M).t list -> Monoid.Unit.t T(M).t
                        val sequence :
                          Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                        val map :
                          'a list -> f:('-> 'T(M).t) -> 'b list T(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T(M).t) ->
                          Monoid.Unit.t T(M).t
                        val fold :
                          'a list ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_left :
                          'a list ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                        val exists :
                          'a list -> f:('-> bool T(M).t) -> bool T(M).t
                        val for_all :
                          'a list -> f:('-> bool T(M).t) -> bool T(M).t
                        val count :
                          'a list ->
                          f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T(M).t) -> 'T(M).t
                        val find :
                          'a list ->
                          f:('-> bool T(M).t) -> 'Option.t T(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                        val filter :
                          'a list -> f:('-> bool T(M).t) -> 'a list T(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T(M).t) -> 'b list T(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T(M).t Core_kernel.Sequence.t ->
                          'Core_kernel.Sequence.t T(M).t
                        val all_ignore :
                          'T(M).t Core_kernel.Sequence.t ->
                          Monoid.Unit.t T(M).t
                        val sequence :
                          Monoid.Unit.t T(M).t Core_kernel.Sequence.t ->
                          Monoid.Unit.t T(M).t
                        val map :
                          'Core_kernel.Sequence.t ->
                          f:('-> 'T(M).t) ->
                          'Core_kernel.Sequence.t T(M).t
                        val iter :
                          'Core_kernel.Sequence.t ->
                          f:('-> Monoid.Unit.t T(M).t) ->
                          Monoid.Unit.t T(M).t
                        val fold :
                          'Core_kernel.Sequence.t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_left :
                          'Core_kernel.Sequence.t ->
                          init:'-> f:('-> '-> 'T(M).t) -> 'T(M).t
                        val fold_right :
                          'Core_kernel.Sequence.t ->
                          f:('-> '-> 'T(M).t) -> init:'-> 'T(M).t
                        val reduce :
                          'Core_kernel.Sequence.t ->
                          f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                        val exists :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> bool T(M).t
                        val for_all :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> bool T(M).t
                        val count :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Sequence.t ->
                          f:('-> 'T(M).t) -> 'T(M).t
                        val find :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) -> 'Option.t T(M).t
                        val find_map :
                          'Core_kernel.Sequence.t ->
                          f:('-> 'Option.t T(M).t) -> 'Option.t T(M).t
                        val filter :
                          'Core_kernel.Sequence.t ->
                          f:('-> bool T(M).t) ->
                          'Core_kernel.Sequence.t T(M).t
                        val filter_map :
                          'Core_kernel.Sequence.t ->
                          f:('-> 'Option.t T(M).t) ->
                          'Core_kernel.Sequence.t T(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T(M).t) ->
                      ('-> 'T(M).t) -> '-> 'T(M).t
                    val ( !! ) : '-> 'T(M).t
                    val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T(M).t ->
                      'T(M).t ->
                      'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                    val ( >>= ) : 'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                    val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                      end
                    val bind : 'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                    val return : '-> 'T(M).t
                    val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                    val join : 'T(M).t T(M).t -> 'T(M).t
                    val ignore_m : 'T(M).t -> Monoid.Unit.t T(M).t
                    val all : 'T(M).t list -> 'a list T(M).t
                    val all_unit :
                      Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                    val all_ignore :
                      Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T(M).t
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T(M).t
                            val bind :
                              'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                            val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                            val both :
                              'T(M).t -> 'T(M).t -> ('a * 'b) T(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                        val ( >=> ) :
                          ('-> 'T(M).t) ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                        val ( !! ) : '-> 'T(M).t
                        val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T(M).t ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                      end
                    type 'a error = exn
                    val fail : exn -> 'T(M).t
                    val catch : 'T(M).t -> (exn -> 'T(M).t) -> 'T(M).t
                  end
            end
        end
      module List :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t list -> 'a list t
                  val all_ignore : 'a t list -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val map : 'a list -> f:('-> 'b t) -> 'b list t
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'a list -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'a list -> f:('-> bool t) -> bool t
                  val for_all : 'a list -> f:('-> bool t) -> bool t
                  val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a t) -> 'a t
                  val find : 'a list -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'a list -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'a list -> f:('-> bool t) -> 'a list t
                  val filter_map :
                    'a list -> f:('-> 'Option.t t) -> 'b list t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Sequence.t ->
                    'Core_kernel.Sequence.t t
                  val all_ignore :
                    'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val sequence :
                    Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'a t) -> 'Option.t t
                  val exists :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Option.t t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Sequence.t t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Core_kernel.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              val pure : '-> 'a t
              val accept : '-> 'a t
              val reject : Monoid.Unit.t -> 'a t
              val guard : bool -> Monoid.Unit.t t
              val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
              val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
              val zero : Monoid.Unit.t -> 'a t
              val plus : 'a t -> 'a t -> 'a t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type ('a, 'e) m
              type ('a, 'e) e
              val lift : ('a, 'e) m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val map :
                    'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                  val iter :
                    'a list ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a list ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a list ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a list -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a list ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                  val filter_map :
                    'a list ->
                    f:('-> ('Option.t, 'e) t) -> ('b list, 'e) t
                end
              module Seq :
                sig
                  val all :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val all_ignore :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t ->
                    f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('Option.t, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val pure : '-> ('a, 'e) t
              val accept : '-> ('a, 'e) t
              val reject : Monoid.Unit.t -> ('a, 'e) t
              val guard : bool -> (Monoid.Unit.t, 'e) t
              val on : bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
              val unless :
                bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
              val zero : Monoid.Unit.t -> ('a, 'e) t
              val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
            end
          type 'a t = 'a list
          type 'a m = 'a
          type 'a e = 'a t
          val lift : '-> 'a e
          val run : 'a e -> 'a e
          val void : 'a e -> Monoid.Unit.t e
          val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
          val forever : 'a e -> 'b e
          module Fn :
            sig
              val id : '-> 'a e
              val ignore : 'a e -> Monoid.Unit.t e
              val nothing : Monoid.Unit.t -> Monoid.Unit.t e
              val non : ('-> bool e) -> '-> bool e
              val apply_n_times :
                n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
              val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
            end
          module Pair :
            sig
              val fst : ('a * 'b) e -> 'a e
              val snd : ('a * 'b) e -> 'b e
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) e -> 'a e
              val snd : ('a * 'b * 'c) e -> 'b e
              val trd : ('a * 'b * 'c) e -> 'c e
            end
          module Lift :
            sig
              val nullary : '-> 'a e
              val unary : ('-> 'b) -> 'a e -> 'b e
              val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ternary :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a e t -> 'a t e
                  val all_ignore : 'a e t -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                  val map : 'a t -> f:('-> 'b e) -> 'b t e
                  val iter :
                    'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a t -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'a t -> f:('-> bool e) -> bool e
                  val for_all : 'a t -> f:('-> bool e) -> bool e
                  val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a e) -> 'a e
                  val find : 'a t -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'a t -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'a t -> f:('-> bool e) -> 'a t e
                  val filter_map : 'a t -> f:('-> 'Option.t e) -> 'b t e
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> Monoid.Unit.t e
                    val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce :
                      'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> Monoid.Int.t e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                    val find_map :
                      'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map :
                      'T.t -> f:('-> 'Option.t e) -> 'T.t e
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> Monoid.Unit.t e
                    val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce :
                      'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> Monoid.Int.t e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                    val find_map :
                      'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map :
                      'T.t -> f:('-> 'Option.t e) -> 'T.t e
                  end
            end
          module List :
            sig
              val all : 'a e e -> 'a e e
              val all_ignore : 'a e e -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
              val map : 'a e -> f:('-> 'b e) -> 'b e e
              val iter : 'a e -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
              val fold : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a e -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a e -> f:('-> '-> 'a e) -> 'Option.t e
              val exists : 'a e -> f:('-> bool e) -> bool e
              val for_all : 'a e -> f:('-> bool e) -> bool e
              val count : 'a e -> f:('-> bool e) -> Monoid.Int.t e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b e -> f:('-> 'a e) -> 'a e
              val find : 'a e -> f:('-> bool e) -> 'Option.t e
              val find_map : 'a e -> f:('-> 'Option.t e) -> 'Option.t e
              val filter : 'a e -> f:('-> bool e) -> 'a e e
              val filter_map : 'a e -> f:('-> 'Option.t e) -> 'b e e
            end
          module Seq :
            sig
              val all :
                'a e Core_kernel.Sequence.t -> 'Core_kernel.Sequence.t e
              val all_ignore : 'a e Core_kernel.Sequence.t -> Monoid.Unit.t e
              val sequence :
                Monoid.Unit.t e Core_kernel.Sequence.t -> Monoid.Unit.t e
              val map :
                'Core_kernel.Sequence.t ->
                f:('-> 'b e) -> 'Core_kernel.Sequence.t e
              val iter :
                'Core_kernel.Sequence.t ->
                f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
              val fold :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left :
                'Core_kernel.Sequence.t ->
                init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'Core_kernel.Sequence.t ->
                f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce :
                'Core_kernel.Sequence.t ->
                f:('-> '-> 'a e) -> 'Option.t e
              val exists :
                'Core_kernel.Sequence.t -> f:('-> bool e) -> bool e
              val for_all :
                'Core_kernel.Sequence.t -> f:('-> bool e) -> bool e
              val count :
                'Core_kernel.Sequence.t ->
                f:('-> bool e) -> Monoid.Int.t e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Core_kernel.Sequence.t -> f:('-> 'a e) -> 'a e
              val find :
                'Core_kernel.Sequence.t ->
                f:('-> bool e) -> 'Option.t e
              val find_map :
                'Core_kernel.Sequence.t ->
                f:('-> 'Option.t e) -> 'Option.t e
              val filter :
                'Core_kernel.Sequence.t ->
                f:('-> bool e) -> 'Core_kernel.Sequence.t e
              val filter_map :
                'Core_kernel.Sequence.t ->
                f:('-> 'Option.t e) -> 'Core_kernel.Sequence.t e
            end
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Monad_infix :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
            end
          val bind : 'a e -> f:('-> 'b e) -> 'b e
          val return : '-> 'a e
          val map : 'a e -> f:('-> 'b) -> 'b e
          val join : 'a e e -> 'a e
          val ignore_m : 'a e -> Monoid.Unit.t e
          val all : 'a e e -> 'a e e
          val all_unit : Monoid.Unit.t e e -> Monoid.Unit.t e
          val all_ignore : Monoid.Unit.t e e -> Monoid.Unit.t e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val bind : 'a e -> f:('-> 'b e) -> 'b e
                  val map : 'a e -> f:('-> 'b) -> 'b e
                  val both : 'a e -> 'b e -> ('a * 'b) e
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          val pure : '-> 'a e
          val accept : '-> 'a e
          val reject : Monoid.Unit.t -> 'a e
          val guard : bool -> Monoid.Unit.t e
          val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
          val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
          val zero : Monoid.Unit.t -> 'a e
          val plus : 'a e -> 'a e -> 'a e
          module T1 :
            functor (M : Core_kernel.T1->
              sig
                type 'a t = 'a list M.t
                type 'a m = 'M.t
                type 'a e = 'Monads.Std.Monad.List.T1.t
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T1(M).t
                val run : 'T1(M).t -> 'Monads.Std.Monad.List.T1.t
                val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val sequence :
                  Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                val forever : 'T1(M).t -> 'T1(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(M).t
                    val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                    val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val compose :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(M).t
                    val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(M).t) ->
                      catch:(exn -> 'T1(M).t) -> 'T1(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(M).t t -> 'a t T1(M).t
                        val all_ignore :
                          'T1(M).t t -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t t -> Monoid.Unit.t T1(M).t
                        val map :
                          'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(M).t e -> 'a e T1(M).t
                    val all_ignore : 'T1(M).t e -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                    val map : 'a e -> f:('-> 'T1(M).t) -> 'b e T1(M).t
                    val iter :
                      'a e ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'a e ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a e ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a e ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a e ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'a e -> f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b e -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a e -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a e ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a e -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                    val filter_map :
                      'a e -> f:('-> 'Option.t T1(M).t) -> 'b e T1(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(M).t
                    val all_ignore :
                      'T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                  end
                val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                val return : '-> 'T1(M).t
                val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                val join : 'T1(M).t T1(M).t -> 'T1(M).t
                val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val all : 'T1(M).t e -> 'a e T1(M).t
                val all_unit :
                  Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                val all_ignore :
                  Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val bind :
                          'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                        val both :
                          'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                val pure : '-> 'T1(M).t
                val accept : '-> 'T1(M).t
                val reject : Monoid.Unit.t -> 'T1(M).t
                val guard : bool -> Monoid.Unit.t T1(M).t
                val on :
                  bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                val unless :
                  bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                val zero : Monoid.Unit.t -> 'T1(M).t
                val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
          module T2 :
            functor (M : Core_kernel.T2->
              sig
                type ('a, 'e) t = ('a list, 'e) M.t
                type ('a, 'e) m = ('a, 'e) M.t
                type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.List.T2.t
              end
          module Make2 :
            functor (M : Monad2->
              sig
                val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                val run :
                  ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.List.T2.t
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t e ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t e -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t e ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a e ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                    val iter :
                      'a e ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a e ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a e ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a e ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a e ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b e -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a e ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val filter_map :
                      'a e ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b e, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t e ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t e ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                val pure : '-> ('a, 'e) T2(M).t
                val accept : '-> ('a, 'e) T2(M).t
                val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
                val on :
                  bool ->
                  (Monoid.Unit.t, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val unless :
                  bool ->
                  (Monoid.Unit.t, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val plus :
                  ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
              end
        end
      module Seq :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Sequence.t ->
                    'Core_kernel.Sequence.t t
                  val all_ignore :
                    'a t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val sequence :
                    Monoid.Unit.t t Core_kernel.Sequence.t -> Monoid.Unit.t t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Sequence.t t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> 'a t) -> 'Option.t t
                  val exists :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Sequence.t -> f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Option.t t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Sequence.t t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> 'Option.t t) -> 'Core_kernel.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              val pure : '-> 'a t
              val accept : '-> 'a t
              val reject : Monoid.Unit.t -> 'a t
              val guard : bool -> Monoid.Unit.t t
              val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
              val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
              val zero : Monoid.Unit.t -> 'a t
              val plus : 'a t -> 'a t -> 'a t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type ('a, 'e) m
              type ('a, 'e) e
              val lift : ('a, 'e) m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val all_ignore :
                    ('a, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Core_kernel.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('b, 'e) t) -> ('Core_kernel.Sequence.t, 'e) t
                  val iter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Core_kernel.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Core_kernel.Sequence.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Sequence.t ->
                    f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Core_kernel.Sequence.t ->
                    f:('-> (bool, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                  val filter_map :
                    'Core_kernel.Sequence.t ->
                    f:('-> ('Option.t, 'e) t) ->
                    ('Core_kernel.Sequence.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val pure : '-> ('a, 'e) t
              val accept : '-> ('a, 'e) t
              val reject : Monoid.Unit.t -> ('a, 'e) t
              val guard : bool -> (Monoid.Unit.t, 'e) t
              val on : bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
              val unless :
                bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
              val zero : Monoid.Unit.t -> ('a, 'e) t
              val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
            end
          type 'a t = 'Core_kernel.Sequence.t
          type 'a m = 'a
          type 'a e = 'a t
          val lift : '-> 'a e
          val run : 'a e -> 'a e
          val void : 'a e -> Monoid.Unit.t e
          val sequence : Monoid.Unit.t e List.t -> Monoid.Unit.t e
          val forever : 'a e -> 'b e
          module Fn :
            sig
              val id : '-> 'a e
              val ignore : 'a e -> Monoid.Unit.t e
              val nothing : Monoid.Unit.t -> Monoid.Unit.t e
              val non : ('-> bool e) -> '-> bool e
              val apply_n_times :
                n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
              val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
            end
          module Pair :
            sig
              val fst : ('a * 'b) e -> 'a e
              val snd : ('a * 'b) e -> 'b e
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) e -> 'a e
              val snd : ('a * 'b * 'c) e -> 'b e
              val trd : ('a * 'b * 'c) e -> 'c e
            end
          module Lift :
            sig
              val nullary : '-> 'a e
              val unary : ('-> 'b) -> 'a e -> 'b e
              val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ternary :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a e t -> 'a t e
                  val all_ignore : 'a e t -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                  val map : 'a t -> f:('-> 'b e) -> 'b t e
                  val iter :
                    'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold : 'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a t -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'a t -> f:('-> bool e) -> bool e
                  val for_all : 'a t -> f:('-> bool e) -> bool e
                  val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a e) -> 'a e
                  val find : 'a t -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'a t -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'a t -> f:('-> bool e) -> 'a t e
                  val filter_map : 'a t -> f:('-> 'Option.t e) -> 'b t e
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> Monoid.Unit.t e
                    val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce :
                      'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> Monoid.Int.t e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                    val find_map :
                      'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map :
                      'T.t -> f:('-> 'Option.t e) -> 'T.t e
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a e T.t -> 'T.t e
                    val all_ignore : 'a e T.t -> Monoid.Unit.t e
                    val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                    val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                    val fold_right :
                      'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                    val reduce :
                      'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                    val exists : 'T.t -> f:('-> bool e) -> bool e
                    val for_all : 'T.t -> f:('-> bool e) -> bool e
                    val count : 'T.t -> f:('-> bool e) -> Monoid.Int.t e
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a e) -> 'a e
                    val find : 'T.t -> f:('-> bool e) -> 'Option.t e
                    val find_map :
                      'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                    val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                    val filter_map :
                      'T.t -> f:('-> 'Option.t e) -> 'T.t e
                  end
            end
          module List :
            sig
              val all : 'a e List.t -> 'List.t e
              val all_ignore : 'a e List.t -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e List.t -> Monoid.Unit.t e
              val map : 'List.t -> f:('-> 'b e) -> 'List.t e
              val iter :
                'List.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
              val fold : 'List.t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'List.t -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'List.t -> f:('-> '-> 'a e) -> 'Option.t e
              val exists : 'List.t -> f:('-> bool e) -> bool e
              val for_all : 'List.t -> f:('-> bool e) -> bool e
              val count : 'List.t -> f:('-> bool e) -> Monoid.Int.t e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a e) -> 'a e
              val find : 'List.t -> f:('-> bool e) -> 'Option.t e
              val find_map :
                'List.t -> f:('-> 'Option.t e) -> 'Option.t e
              val filter : 'List.t -> f:('-> bool e) -> 'List.t e
              val filter_map :
                'List.t -> f:('-> 'Option.t e) -> 'List.t e
            end
          module Seq :
            sig
              val all : 'a e e -> 'a e e
              val all_ignore : 'a e e -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
              val map : 'a e -> f:('-> 'b e) -> 'b e e
              val iter : 'a e -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
              val fold : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_left : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
              val fold_right :
                'a e -> f:('-> '-> 'b e) -> init:'-> 'b e
              val reduce : 'a e -> f:('-> '-> 'a e) -> 'Option.t e
              val exists : 'a e -> f:('-> bool e) -> bool e
              val for_all : 'a e -> f:('-> bool e) -> bool e
              val count : 'a e -> f:('-> bool e) -> Monoid.Int.t e
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'b e -> f:('-> 'a e) -> 'a e
              val find : 'a e -> f:('-> bool e) -> 'Option.t e
              val find_map : 'a e -> f:('-> 'Option.t e) -> 'Option.t e
              val filter : 'a e -> f:('-> bool e) -> 'a e e
              val filter_map : 'a e -> f:('-> 'Option.t e) -> 'b e e
            end
          val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
          val ( !! ) : '-> 'a e
          val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
          val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
          val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
          val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
          module Monad_infix :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
            end
          val bind : 'a e -> f:('-> 'b e) -> 'b e
          val return : '-> 'a e
          val map : 'a e -> f:('-> 'b) -> 'b e
          val join : 'a e e -> 'a e
          val ignore_m : 'a e -> Monoid.Unit.t e
          val all : 'a e list -> 'a list e
          val all_unit : Monoid.Unit.t e list -> Monoid.Unit.t e
          val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
          module Let_syntax :
            sig
              val return : '-> 'a e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val bind : 'a e -> f:('-> 'b e) -> 'b e
                  val map : 'a e -> f:('-> 'b) -> 'b e
                  val both : 'a e -> 'b e -> ('a * 'b) e
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
            end
          val pure : '-> 'a e
          val accept : '-> 'a e
          val reject : Monoid.Unit.t -> 'a e
          val guard : bool -> Monoid.Unit.t e
          val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
          val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
          val zero : Monoid.Unit.t -> 'a e
          val plus : 'a e -> 'a e -> 'a e
          module T1 :
            functor (M : Core_kernel.T1->
              sig
                type 'a t = 'Core_kernel.Sequence.t M.t
                type 'a m = 'M.t
                type 'a e = 'Monads.Std.Monad.Seq.T1.t
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T1(M).t
                val run : 'T1(M).t -> 'Monads.Std.Monad.Seq.T1.t
                val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val sequence :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val forever : 'T1(M).t -> 'T1(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(M).t
                    val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                    val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val compose :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(M).t
                    val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(M).t) ->
                      catch:(exn -> 'T1(M).t) -> 'T1(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(M).t t -> 'a t T1(M).t
                        val all_ignore :
                          'T1(M).t t -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t t -> Monoid.Unit.t T1(M).t
                        val map :
                          'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore : 'T1(M).t list -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val map :
                      'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
                  end
                module Seq :
                  sig
                    val all : 'T1(M).t e -> 'a e T1(M).t
                    val all_ignore : 'T1(M).t e -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                    val map : 'a e -> f:('-> 'T1(M).t) -> 'b e T1(M).t
                    val iter :
                      'a e ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'a e ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a e ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a e ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a e ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'a e -> f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b e -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a e -> f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a e ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a e -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                    val filter_map :
                      'a e -> f:('-> 'Option.t T1(M).t) -> 'b e T1(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                  end
                val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                val return : '-> 'T1(M).t
                val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                val join : 'T1(M).t T1(M).t -> 'T1(M).t
                val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_unit :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val all_ignore :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val bind :
                          'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                        val both :
                          'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                val pure : '-> 'T1(M).t
                val accept : '-> 'T1(M).t
                val reject : Monoid.Unit.t -> 'T1(M).t
                val guard : bool -> Monoid.Unit.t T1(M).t
                val on :
                  bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                val unless :
                  bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                val zero : Monoid.Unit.t -> 'T1(M).t
                val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
              end
          module T2 :
            functor (M : Core_kernel.T2->
              sig
                type ('a, 'e) t = ('Core_kernel.Sequence.t, 'e) M.t
                type ('a, 'e) m = ('a, 'e) M.t
                type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Seq.T2.t
              end
          module Make2 :
            functor (M : Monad2->
              sig
                val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                val run :
                  ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Seq.T2.t
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t e -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t e ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a e ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                    val iter :
                      'a e ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a e ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a e ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a e ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a e ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b e -> f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a e ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a e ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                    val filter_map :
                      'a e ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b e, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                val pure : '-> ('a, 'e) T2(M).t
                val accept : '-> ('a, 'e) T2(M).t
                val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
                val on :
                  bool ->
                  (Monoid.Unit.t, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val unless :
                  bool ->
                  (Monoid.Unit.t, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
                val plus :
                  ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
              end
        end
      module Writer :
        sig
          module type S =
            sig
              type state
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val write : Monads.Std.Monad.Writer.S.state -> unit t
              val read : 'a t -> Monads.Std.Monad.Writer.S.state t
              val listen : 'a t -> ('a * Monads.Std.Monad.Writer.S.state) t
              val exec : unit t -> Monads.Std.Monad.Writer.S.state m
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
            end
          type ('a, 'b) writer
          module T1 :
            functor (T : Monoid.S) (M : Monad->
              sig
                type state = T.t
                type 'a m = 'M.t
                type 'a t =
                    ('a, Monads.Std.Monad.Writer.T1.state)
                    Monads.Std.Monad.Writer.writer
                    Monads.Std.Monad.Writer.T1.m
                type 'a e =
                    ('a * Monads.Std.Monad.Writer.T1.state)
                    Monads.Std.Monad.Writer.T1.m
              end
          module Make :
            functor (T : Monoid.S) (M : Monad->
              sig
                val lift : 'M.t -> 'T1(T)(M).t
                val run : 'T1(T)(M).t -> 'T1(T)(M).e
                val write : T.t -> Monoid.Unit.t T1(T)(M).t
                val read : 'T1(T)(M).t -> T.t T1(T)(M).t
                val listen : 'T1(T)(M).t -> ('a * T.t) T1(T)(M).t
                val exec : Monoid.Unit.t T1(T)(M).t -> T.t M.t
                val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val sequence :
                  Monoid.Unit.t T1(T)(M).t List.t -> Monoid.Unit.t T1(T)(M).t
                val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(T)(M).t
                    val ignore : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                    val non :
                      ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val compose :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(T)(M).t
                    val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                      catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(T)(M).t List.t -> 'List.t T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t List.t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t List.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'List.t ->
                      f:('-> 'T1(T)(M).t) -> 'List.t T1(T)(M).t
                    val iter :
                      'List.t ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'List.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'List.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'List.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'List.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'List.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'List.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'List.t ->
                      f:('-> bool T1(T)(M).t) -> 'List.t T1(T)(M).t
                    val filter_map :
                      'List.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'List.t T1(T)(M).t
                  end
                module Seq :
                  sig
                    val all : 'T1(T)(M).t Seq.t -> 'Seq.t T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t Seq.t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t Seq.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'Seq.t ->
                      f:('-> 'T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                    val iter :
                      'Seq.t ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'Seq.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'Seq.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'Seq.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'Seq.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Seq.t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'Seq.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'Seq.t ->
                      f:('-> bool T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                    val filter_map :
                      'Seq.t ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                  end
                val bind :
                  'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val return : '-> 'T1(T)(M).t
                val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_unit :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val all_ignore :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val both :
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
              end
        end
      module Reader :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              type env
              val read : unit -> Monads.Std.Monad.Reader.S.env t
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type 'a m
              type ('a, 'e) e
              val lift : 'a m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val read : unit -> ('e, 'e) t
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
            end
          type ('a, 'b) reader
          type ('a, 'e) t = ('a, 'e) reader
          type 'a m = 'a
          type ('a, 'e) e = '-> 'a
          val lift : '-> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val read : Monoid.Unit.t -> ('e, 'e) t
          val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val sequence :
            (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                f:(Monoid.Unit.t -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) reader t -> ('a t, 'e) reader
                  val all_ignore :
                    ('a, 'e) reader t -> (Monoid.Unit.t, 'e) reader
                  val sequence :
                    (Monoid.Unit.t, 'e) reader t ->
                    (Monoid.Unit.t, 'e) reader
                  val map :
                    'a t -> f:('-> ('b, 'e) reader) -> ('b t, 'e) reader
                  val iter :
                    'a t ->
                    f:('-> (Monoid.Unit.t, 'e) reader) ->
                    (Monoid.Unit.t, 'e) reader
                  val fold :
                    'a t ->
                    init:'->
                    f:('-> '-> ('b, 'e) reader) -> ('b, 'e) reader
                  val fold_left :
                    'a t ->
                    init:'->
                    f:('-> '-> ('b, 'e) reader) -> ('b, 'e) reader
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) reader) ->
                    init:'-> ('b, 'e) reader
                  val reduce :
                    'a t ->
                    f:('-> '-> ('a, 'e) reader) ->
                    ('Option.t, 'e) reader
                  val exists :
                    'a t -> f:('-> (bool, 'e) reader) -> (bool, 'e) reader
                  val for_all :
                    'a t -> f:('-> (bool, 'e) reader) -> (bool, 'e) reader
                  val count :
                    'a t ->
                    f:('-> (bool, 'e) reader) -> (Monoid.Int.t, 'e) reader
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) reader) -> ('a, 'e) reader
                  val find :
                    'a t ->
                    f:('-> (bool, 'e) reader) -> ('Option.t, 'e) reader
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) reader) ->
                    ('Option.t, 'e) reader
                  val filter :
                    'a t -> f:('-> (bool, 'e) reader) -> ('a t, 'e) reader
                  val filter_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) reader) -> ('b t, 'e) reader
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter :
                'List.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'List.t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter :
                'Seq.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Seq.t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_unit : (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          val all_ignore :
            (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module T1 :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                type env = T.t
                type 'a m = 'M.t
                type 'a t =
                    ('Monads.Std.Monad.Reader.T1.m,
                     Monads.Std.Monad.Reader.T1.env)
                    Monads.Std.Monad.Reader.reader
                type 'a e =
                    Monads.Std.Monad.Reader.T1.env ->
                    'Monads.Std.Monad.Reader.T1.m
              end
          module T2 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type ('a, 'e) t =
                    ('Monads.Std.Monad.Reader.T2.m, 'e)
                    Monads.Std.Monad.Reader.reader
                type ('a, 'e) e = '-> 'Monads.Std.Monad.Reader.T2.m
              end
          module Make :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                val lift : 'M.t -> 'T1(T)(M).t
                val run : 'T1(T)(M).t -> 'T1(T)(M).e
                val read : Monoid.Unit.t -> T.t T1(T)(M).t
                val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val sequence :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(T)(M).t
                    val ignore : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                    val non :
                      ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val compose :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(T)(M).t
                    val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                      catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'a list ->
                      f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                  end
                val bind :
                  'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val return : '-> 'T1(T)(M).t
                val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_unit :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val all_ignore :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val both :
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
              end
          module Make2 :
            functor (M : Monad->
              sig
                val lift : 'M.t -> ('a, 'e) T2(M).t
                val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                val read : Monoid.Unit.t -> ('e, 'e) T2(M).t
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
              end
        end
      module State :
        sig
          type ('a, 'e) storage
          type ('a, 'e) state
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              type env
              val put : Monads.Std.Monad.State.S.env -> unit t
              val get : unit -> Monads.Std.Monad.State.S.env t
              val gets : (Monads.Std.Monad.State.S.env -> 'r) -> 'r t
              val update :
                (Monads.Std.Monad.State.S.env -> Monads.Std.Monad.State.S.env) ->
                unit t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type 'a m
              type ('a, 'e) e
              val lift : 'a m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val put : '-> (unit, 's) t
              val get : unit -> ('s, 's) t
              val gets : ('-> 'r) -> ('r, 's) t
              val update : ('-> 's) -> (unit, 's) t
            end
          module Multi :
            sig
              type status = [ `Current | `Dead | `Live ]
              type 'a contexts
              type id
              module Id :
                sig
                  type t = id
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                  val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                  val of_string : Monoid.String.t -> t
                  val to_string : t -> Monoid.String.t
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> Monoid.Int.t
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> Monoid.Int.t
                  val descending : t -> t -> Monoid.Int.t
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> Monoid.Int.t
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = id
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Map_intf.Tree.t
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) List.t ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) List.t -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) List.t -> 'a t
                          val of_alist_multi :
                            (id * 'a) List.t -> 'List.t t
                          val of_alist_fold :
                            (id * 'a) List.t ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t ->
                            f:(Monoid.Int.t -> id * 'a) -> 'a t
                          val of_increasing_sequence :
                            (id * 'a) Base__.Sequence.t ->
                            'a t Base__.Or_error.t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                   Monoid.Unit.t) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Core_kernel__.Hashtbl.t -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> Monoid.Int.t
                          val add :
                            'a t ->
                            key:id ->
                            data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                          val add_exn : 'a t -> key:id -> data:'-> 'a t
                          val set : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'List.t t -> key:id -> data:'-> 'List.t t
                          val remove_multi : 'List.t t -> id -> 'List.t t
                          val find_multi : 'List.t t -> id -> 'List.t
                          val change :
                            'a t ->
                            id -> f:('Option.t -> 'Option.t) -> 'a t
                          val update :
                            'a t -> id -> f:('Option.t -> 'a) -> 'a t
                          val find : 'a t -> id -> 'Option.t
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys :
                            'a t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'Option.t) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'Option.t) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> Monoid.Int.t) ->
                            'a t -> 'a t -> Monoid.Int.t
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id List.t
                          val data : 'a t -> 'List.t
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) List.t
                          val validate :
                            name:(id -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a) Base__.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) Option.t
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) Option.t
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val counti :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> Monoid.Int.t
                          val split :
                            'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) List.t
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) Option.t
                          val nth :
                            'a t -> Monoid.Int.t -> (id * 'a) Option.t
                          val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                          val rank : 'a t -> id -> Monoid.Int.t Option.t
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp :
                                       Ppx_sexp_conv_lib.Sexp.t -> id
                                   end->
                              sig
                                val t_of_sexp :
                                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                        end
                      type 'a t =
                          (id, 'a, comparator_witness)
                          Core_kernel__.Map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : id -> '-> 'a t
                      val of_alist :
                        (id * 'a) List.t ->
                        [ `Duplicate_key of id | `Ok of 'a t ]
                      val of_alist_or_error :
                        (id * 'a) List.t -> 'a t Base__.Or_error.t
                      val of_alist_exn : (id * 'a) List.t -> 'a t
                      val of_alist_multi : (id * 'a) List.t -> 'List.t t
                      val of_alist_fold :
                        (id * 'a) List.t ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (id * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:Monoid.Int.t ->
                        f:(Monoid.Int.t -> id * 'a) -> 'a t
                      val of_increasing_sequence :
                        (id * 'a) Base__.Sequence.t -> 'a t Base__.Or_error.t
                      val of_iteri :
                        iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                               Monoid.Unit.t) ->
                        [ `Duplicate_key of id | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (id, 'a) Core_kernel__.Hashtbl.t -> 'a t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> Monoid.Int.t
                      val add :
                        'a t ->
                        key:id ->
                        data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                      val add_exn : 'a t -> key:id -> data:'-> 'a t
                      val set : 'a t -> key:id -> data:'-> 'a t
                      val add_multi :
                        'List.t t -> key:id -> data:'-> 'List.t t
                      val remove_multi : 'List.t t -> id -> 'List.t t
                      val find_multi : 'List.t t -> id -> 'List.t
                      val change :
                        'a t -> id -> f:('Option.t -> 'Option.t) -> 'a t
                      val update :
                        'a t -> id -> f:('Option.t -> 'a) -> 'a t
                      val find : 'a t -> id -> 'Option.t
                      val find_exn : 'a t -> id -> 'a
                      val remove : 'a t -> id -> 'a t
                      val mem : 'a t -> id -> bool
                      val iter_keys :
                        'a t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                      val iteri :
                        'a t ->
                        f:(key:id -> data:'-> Monoid.Unit.t) ->
                        Monoid.Unit.t
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           Monoid.Unit.t) ->
                        Monoid.Unit.t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'Option.t) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:id -> data:'-> 'Option.t) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> Monoid.Int.t) ->
                        'a t -> 'a t -> Monoid.Int.t
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> id List.t
                      val data : 'a t -> 'List.t
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (id * 'a) List.t
                      val validate :
                        name:(id -> Monoid.String.t) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (id, 'a) Base__.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (id * 'a) Option.t
                      val min_elt_exn : 'a t -> id * 'a
                      val max_elt : 'a t -> (id * 'a) Option.t
                      val max_elt_exn : 'a t -> id * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                      val counti :
                        'a t -> f:(key:id -> data:'-> bool) -> Monoid.Int.t
                      val split :
                        'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:id Base__.Maybe_bound.t ->
                        upper_bound:id Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:id ->
                        max:id ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:id -> max:id -> (id * 'a) List.t
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> id -> (id * 'a) Option.t
                      val nth : 'a t -> Monoid.Int.t -> (id * 'a) Option.t
                      val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                      val rank : 'a t -> id -> Monoid.Int.t Option.t
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:id ->
                        ?keys_less_or_equal_to:id ->
                        'a t -> (id * 'a) Base__.Sequence.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> id
                                 end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, Monoid.Int.t -> 'a t)
                              Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                        Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = id
                          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (id, comparator_witness)
                              Core_kernel__.Set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          type named =
                              (id, comparator_witness)
                              Core_kernel__.Set_intf.Tree.Named.t
                          val length : t -> Monoid.Int.t
                          val is_empty : t -> bool
                          val iter :
                            t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id Option.t
                          val find_map :
                            t -> f:(id -> 'Option.t) -> 'Option.t
                          val to_list : t -> id List.t
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> Monoid.Int.t
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          module Named :
                            sig
                              val is_subset :
                                named ->
                                of_:named -> Monoid.Unit.t Base__.Or_error.t
                              val equal :
                                named ->
                                named -> Monoid.Unit.t Base__.Or_error.t
                            end
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'final)
                               Base__.Set_intf.Continue_or_stop.t) ->
                            finish:('-> 'final) -> 'final
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id List.t
                          val min_elt : t -> id Option.t
                          val min_elt_exn : t -> id
                          val max_elt : t -> id Option.t
                          val max_elt_exn : t -> id
                          val choose : t -> id Option.t
                          val choose_exn : t -> id
                          val split : t -> id -> t * id Option.t * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t List.t
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> Monoid.Int.t -> id Option.t
                          val nth : t -> Monoid.Int.t -> id Option.t
                          val remove_index : t -> Monoid.Int.t -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Base__.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t List.t -> t
                          val of_list : id List.t -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t -> f:(Monoid.Int.t -> id) -> t
                          val stable_dedup_list : id List.t -> id List.t
                          val map :
                            ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                            f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                            f:('-> id Option.t) -> t
                          val of_tree : t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Core_kernel__.Hashtbl.t -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness) Core_kernel__.Map.t ->
                            t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> id
                                     end->
                              sig
                                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              end
                          val t_of_sexp :
                            Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                          val sexp_of_t :
                            t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                        end
                      type t = (id, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      type named =
                          (id, comparator_witness)
                          Core_kernel__.Set_intf.Named.t
                      val length : t -> Monoid.Int.t
                      val is_empty : t -> bool
                      val iter :
                        t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(id -> bool) -> bool
                      val for_all : t -> f:(id -> bool) -> bool
                      val count : t -> f:(id -> bool) -> Monoid.Int.t
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(id -> 'sum) -> 'sum
                      val find : t -> f:(id -> bool) -> id Option.t
                      val find_map :
                        t -> f:(id -> 'Option.t) -> 'Option.t
                      val to_list : t -> id List.t
                      val to_array : t -> id array
                      val invariants : t -> bool
                      val mem : t -> id -> bool
                      val add : t -> id -> t
                      val remove : t -> id -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> Monoid.Int.t
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      module Named :
                        sig
                          val is_subset :
                            named ->
                            of_:named -> Monoid.Unit.t Base__.Or_error.t
                          val equal :
                            named -> named -> Monoid.Unit.t Base__.Or_error.t
                        end
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           id ->
                           ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ->
                        finish:('-> 'final) -> 'final
                      val fold_right :
                        t -> init:'-> f:(id -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of id * id | `Left of id | `Right of id ] ->
                           Monoid.Unit.t) ->
                        Monoid.Unit.t
                      val filter : t -> f:(id -> bool) -> t
                      val partition_tf : t -> f:(id -> bool) -> t * t
                      val elements : t -> id List.t
                      val min_elt : t -> id Option.t
                      val min_elt_exn : t -> id
                      val max_elt : t -> id Option.t
                      val max_elt_exn : t -> id
                      val choose : t -> id Option.t
                      val choose_exn : t -> id
                      val split : t -> id -> t * id Option.t * t
                      val group_by :
                        t -> equiv:(id -> id -> bool) -> t List.t
                      val find_exn : t -> f:(id -> bool) -> id
                      val find_index : t -> Monoid.Int.t -> id Option.t
                      val nth : t -> Monoid.Int.t -> id Option.t
                      val remove_index : t -> Monoid.Int.t -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id ->
                        t ->
                        t ->
                        (id, id) Base__.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(id -> 'data) ->
                        (id, 'data, comparator_witness) Core_kernel__.Map.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : id -> t
                      val union_list : t List.t -> t
                      val of_list : id List.t -> t
                      val of_array : id array -> t
                      val of_sorted_array : id array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : id array -> t
                      val of_increasing_iterator_unchecked :
                        len:Monoid.Int.t -> f:(Monoid.Int.t -> id) -> t
                      val stable_dedup_list : id List.t -> id List.t
                      val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : id Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (id, 'a) Core_kernel__.Hashtbl.t -> t
                      val of_map_keys :
                        (id, 'a, comparator_witness) Core_kernel__.Map.t -> t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> id
                                 end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Monoid.Int.t -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Monoid.Int.t -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  val hash_fold_t :
                    Ppx_hash_lib.Std.Hash.state ->
                    t -> Ppx_hash_lib.Std.Hash.state
                  val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  val hashable : t Core_kernel__.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl =
                          ('a, 'b) Core_kernel__.Hashtbl.t
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'b t -> Ppx_sexp_conv_lib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, Monoid.Unit.t -> 'b t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) List.t ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b,
                         (key * 'b) List.t -> 'b t Base__.Or_error.t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) List.t -> 'b t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'List.t, (key * 'b) List.t -> 'List.t t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'List.t ->
                         [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'List.t -> 'r t Base__.Or_error.t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'List.t -> 'r t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'List.t -> 'b t)
                        Core_kernel__.Hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> Monoid.Unit.t
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys :
                        'a t -> f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
                      val iter :
                        'b t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                      val iteri :
                        'b t ->
                        f:(key:key -> data:'-> Monoid.Unit.t) ->
                        Monoid.Unit.t
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t ->
                        f:(key:key -> data:'-> bool) -> Monoid.Int.t
                      val count : 'b t -> f:('-> bool) -> Monoid.Int.t
                      val length : 'a t -> Monoid.Int.t
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> Monoid.Unit.t
                      val set : 'b t -> key:key -> data:'-> Monoid.Unit.t
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_exn :
                        'b t -> key:key -> data:'-> Monoid.Unit.t
                      val change :
                        'b t ->
                        key ->
                        f:('Option.t -> 'Option.t) -> Monoid.Unit.t
                      val update :
                        'b t -> key -> f:('Option.t -> 'b) -> Monoid.Unit.t
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'Option.t) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'Option.t) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(Monoid.Unit.t -> 'b) -> 'b
                      val findi_or_add :
                        'b t -> key -> default:(key -> 'b) -> 'b
                      val find : 'b t -> key -> 'Option.t
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val findi_and_call :
                        'b t ->
                        key ->
                        if_found:(key:key -> data:'-> 'c) ->
                        if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'Option.t
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'Option.t) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key ->
                           '-> 'Option.t -> 'b merge_into_action) ->
                        Monoid.Unit.t
                      val keys : 'a t -> key List.t
                      val data : 'b t -> 'List.t
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> Monoid.Unit.t
                      val filter_inplace :
                        'b t -> f:('-> bool) -> Monoid.Unit.t
                      val filteri_inplace :
                        'b t ->
                        f:(key:key -> data:'-> bool) -> Monoid.Unit.t
                      val map_inplace : 'b t -> f:('-> 'b) -> Monoid.Unit.t
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                      val filter_map_inplace :
                        'b t -> f:('-> 'Option.t) -> Monoid.Unit.t
                      val filter_mapi_inplace :
                        'b t ->
                        f:(key:key -> data:'-> 'Option.t) ->
                        Monoid.Unit.t
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) List.t
                      val validate :
                        name:(key -> Monoid.String.t) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:Monoid.Int.t ->
                        ?remove_if_zero:bool ->
                        Monoid.Int.t t -> key -> Monoid.Unit.t
                      val decr :
                        ?by:Monoid.Int.t ->
                        ?remove_if_zero:bool ->
                        Monoid.Int.t t -> key -> Monoid.Unit.t
                      val add_multi :
                        'List.t t -> key:key -> data:'-> Monoid.Unit.t
                      val remove_multi : 'List.t t -> key -> Monoid.Unit.t
                      val find_multi : 'List.t t -> key -> 'List.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp :
                                     Ppx_sexp_conv_lib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                              Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                        Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, Monoid.Unit.t -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                      val of_list :
                        ('a, elt List.t -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                      module Provide_of_sexp :
                        functor
                          (X : sig
                                 val t_of_sexp :
                                   Ppx_sexp_conv_lib.Sexp.t -> elt
                               end->
                          sig
                            val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Monoid.Int.t -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = id
                          val compare : t -> t -> Monoid.Int.t
                          val sexp_of_t :
                            t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                          val hash : t -> Monoid.Int.t
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                        'a t -> Ppx_sexp_conv_lib.Sexp.t
                      val length : 'a t -> Monoid.Int.t
                      val is_empty : 'a t -> bool
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'final)
                           Base__.Container_intf.Continue_or_stop.t) ->
                        finish:('accum -> 'final) -> 'final
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'Option.t
                      val find_map :
                        'a t -> f:('-> 'Option.t) -> 'Option.t
                      val to_list : 'a t -> 'List.t
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t ->
                        compare:('-> '-> Monoid.Int.t) -> 'Option.t
                      val max_elt :
                        'a t ->
                        compare:('-> '-> Monoid.Int.t) -> 'Option.t
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> id -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> id -> 'a
                      val enqueue :
                        'a t -> id -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> id Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> id * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> id -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> id -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:id -> data:'-> 'b) -> 'b
                    end
                  val pp :
                    Stdlib.Format.formatter ->
                    Monads.Std.Monad.State.Multi.id -> unit
                end
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  type id
                  module Id :
                    sig
                      type t = id
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      val of_string : Monoid.String.t -> t
                      val to_string : t -> Monoid.String.t
                      val pp : Base__.Formatter.t -> t -> Monoid.Unit.t
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> Monoid.Int.t
                      val min : t -> t -> t
                      val max : t -> t -> t
                      val ascending : t -> t -> Monoid.Int.t
                      val descending : t -> t -> Monoid.Int.t
                      val between : t -> low:t -> high:t -> bool
                      val clamp_exn : t -> min:t -> max:t -> t
                      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                      type comparator_witness
                      val validate_lbound :
                        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      val validate_ubound :
                        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      val validate_bound :
                        min:t Base__.Maybe_bound.t ->
                        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      module Replace_polymorphic_compare :
                        sig
                          val ( >= ) : t -> t -> bool
                          val ( <= ) : t -> t -> bool
                          val ( = ) : t -> t -> bool
                          val ( > ) : t -> t -> bool
                          val ( < ) : t -> t -> bool
                          val ( <> ) : t -> t -> bool
                          val equal : t -> t -> bool
                          val compare : t -> t -> Monoid.Int.t
                          val min : t -> t -> t
                          val max : t -> t -> t
                        end
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                      module Map :
                        sig
                          module Key :
                            sig
                              type t = id
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                              type comparator_witness = comparator_witness
                              val comparator :
                                (t, comparator_witness)
                                Core_kernel__.Comparator.comparator
                            end
                          module Tree :
                            sig
                              type 'a t =
                                  (id, 'a, comparator_witness)
                                  Core_kernel__.Map_intf.Tree.t
                              val empty : 'a t
                              val singleton : id -> '-> 'a t
                              val of_alist :
                                (id * 'a) List.t ->
                                [ `Duplicate_key of id | `Ok of 'a t ]
                              val of_alist_or_error :
                                (id * 'a) List.t -> 'a t Base__.Or_error.t
                              val of_alist_exn : (id * 'a) List.t -> 'a t
                              val of_alist_multi :
                                (id * 'a) List.t -> 'List.t t
                              val of_alist_fold :
                                (id * 'a) List.t ->
                                init:'-> f:('-> '-> 'b) -> 'b t
                              val of_alist_reduce :
                                (id * 'a) List.t ->
                                f:('-> '-> 'a) -> 'a t
                              val of_sorted_array :
                                (id * 'a) array -> 'a t Base__.Or_error.t
                              val of_sorted_array_unchecked :
                                (id * 'a) array -> 'a t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id * 'a) -> 'a t
                              val of_increasing_sequence :
                                (id * 'a) Base__.Sequence.t ->
                                'a t Base__.Or_error.t
                              val of_iteri :
                                iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                       Monoid.Unit.t) ->
                                [ `Duplicate_key of id | `Ok of 'v t ]
                              val of_tree : 'a t -> 'a t
                              val of_hashtbl_exn :
                                (id, 'a) Id.Table.hashtbl -> 'a t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                'Core_kernel__.Quickcheck.Generator.t ->
                                'a t Core_kernel__.Quickcheck.Generator.t
                              val invariants : 'a t -> bool
                              val is_empty : 'a t -> bool
                              val length : 'a t -> Monoid.Int.t
                              val add :
                                'a t ->
                                key:id ->
                                data:'->
                                'a t Base__.Map_intf.Or_duplicate.t
                              val add_exn : 'a t -> key:id -> data:'-> 'a t
                              val set : 'a t -> key:id -> data:'-> 'a t
                              val add_multi :
                                'List.t t ->
                                key:id -> data:'-> 'List.t t
                              val remove_multi :
                                'List.t t -> id -> 'List.t t
                              val find_multi : 'List.t t -> id -> 'List.t
                              val change :
                                'a t ->
                                id -> f:('Option.t -> 'Option.t) -> 'a t
                              val update :
                                'a t -> id -> f:('Option.t -> 'a) -> 'a t
                              val find : 'a t -> id -> 'Option.t
                              val find_exn : 'a t -> id -> 'a
                              val remove : 'a t -> id -> 'a t
                              val mem : 'a t -> id -> bool
                              val iter_keys :
                                'a t ->
                                f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'a t ->
                                f:(key:id -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter2 :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val mapi :
                                'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                              val fold :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold_right :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold2 :
                                'a t ->
                                'b t ->
                                init:'->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   '-> 'c) ->
                                'c
                              val filter_keys :
                                'a t -> f:(id -> bool) -> 'a t
                              val filter : 'a t -> f:('-> bool) -> 'a t
                              val filteri :
                                'a t -> f:(key:id -> data:'-> bool) -> 'a t
                              val filter_map :
                                'a t -> f:('-> 'Option.t) -> 'b t
                              val filter_mapi :
                                'a t ->
                                f:(key:id -> data:'-> 'Option.t) -> 'b t
                              val partition_mapi :
                                'a t ->
                                f:(key:id ->
                                   data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partition_map :
                                'a t ->
                                f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partitioni_tf :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> 'a t * 'a t
                              val partition_tf :
                                'a t -> f:('-> bool) -> 'a t * 'a t
                              val compare_direct :
                                ('-> '-> Monoid.Int.t) ->
                                'a t -> 'a t -> Monoid.Int.t
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val keys : 'a t -> id List.t
                              val data : 'a t -> 'List.t
                              val to_alist :
                                ?key_order:[ `Decreasing | `Increasing ] ->
                                'a t -> (id * 'a) List.t
                              val validate :
                                name:(id -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'a t Base__.Validate.check
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              val symmetric_diff :
                                'a t ->
                                'a t ->
                                data_equal:('-> '-> bool) ->
                                (id, 'a)
                                Base__.Map_intf.Symmetric_diff_element.t
                                Base__.Sequence.t
                              val min_elt : 'a t -> (id * 'a) Option.t
                              val min_elt_exn : 'a t -> id * 'a
                              val max_elt : 'a t -> (id * 'a) Option.t
                              val max_elt_exn : 'a t -> id * 'a
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val for_alli :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val exists : 'a t -> f:('-> bool) -> bool
                              val existsi :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val counti :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> Monoid.Int.t
                              val split :
                                'a t ->
                                id -> 'a t * (id * 'a) Option.t * 'a t
                              val append :
                                lower_part:'a t ->
                                upper_part:'a t ->
                                [ `Ok of 'a t | `Overlapping_key_ranges ]
                              val subrange :
                                'a t ->
                                lower_bound:id Base__.Maybe_bound.t ->
                                upper_bound:id Base__.Maybe_bound.t -> 'a t
                              val fold_range_inclusive :
                                'a t ->
                                min:id ->
                                max:id ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val range_to_alist :
                                'a t -> min:id -> max:id -> (id * 'a) List.t
                              val closest_key :
                                'a t ->
                                [ `Greater_or_equal_to
                                | `Greater_than
                                | `Less_or_equal_to
                                | `Less_than ] -> id -> (id * 'a) Option.t
                              val nth :
                                'a t -> Monoid.Int.t -> (id * 'a) Option.t
                              val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                              val rank : 'a t -> id -> Monoid.Int.t Option.t
                              val to_tree : 'a t -> 'a t
                              val to_sequence :
                                ?order:[ `Decreasing_key | `Increasing_key ] ->
                                ?keys_greater_or_equal_to:id ->
                                ?keys_less_or_equal_to:id ->
                                'a t -> (id * 'a) Base__.Sequence.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                'Core_kernel__.Quickcheck.Observer.t ->
                                'v t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                'Core_kernel__.Quickcheck.Shrinker.t ->
                                'v t Core_kernel__.Quickcheck.Shrinker.t
                              module Provide_of_sexp :
                                functor
                                  (K : sig
                                         val t_of_sexp :
                                           Ppx_sexp_conv_lib.Sexp.t -> id
                                       end->
                                  sig
                                    val t_of_sexp :
                                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                                      Ppx_sexp_conv_lib.Sexp.t ->
                                      'v_x__017_ t
                                  end
                              val t_of_sexp :
                                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                              val sexp_of_t :
                                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                            end
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Map_intf.Map.t
                          val compare :
                            ('-> '-> Core_kernel__.Import.int) ->
                            'a t -> 'a t -> Core_kernel__.Import.int
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) List.t ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) List.t -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) List.t -> 'a t
                          val of_alist_multi :
                            (id * 'a) List.t -> 'List.t t
                          val of_alist_fold :
                            (id * 'a) List.t ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t ->
                            f:(Monoid.Int.t -> id * 'a) -> 'a t
                          val of_increasing_sequence :
                            (id * 'a) Base__.Sequence.t ->
                            'a t Base__.Or_error.t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                   Monoid.Unit.t) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'Tree.t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Id.Table.hashtbl -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> Monoid.Int.t
                          val add :
                            'a t ->
                            key:id ->
                            data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                          val add_exn : 'a t -> key:id -> data:'-> 'a t
                          val set : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'List.t t -> key:id -> data:'-> 'List.t t
                          val remove_multi : 'List.t t -> id -> 'List.t t
                          val find_multi : 'List.t t -> id -> 'List.t
                          val change :
                            'a t ->
                            id -> f:('Option.t -> 'Option.t) -> 'a t
                          val update :
                            'a t -> id -> f:('Option.t -> 'a) -> 'a t
                          val find : 'a t -> id -> 'Option.t
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys :
                            'a t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'Option.t) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'Option.t) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> Monoid.Int.t) ->
                            'a t -> 'a t -> Monoid.Int.t
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id List.t
                          val data : 'a t -> 'List.t
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) List.t
                          val validate :
                            name:(id -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a) Base__.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) Option.t
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) Option.t
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val counti :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> Monoid.Int.t
                          val split :
                            'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) List.t
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) Option.t
                          val nth :
                            'a t -> Monoid.Int.t -> (id * 'a) Option.t
                          val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                          val rank : 'a t -> id -> Monoid.Int.t Option.t
                          val to_tree : 'a t -> 'Tree.t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (Key : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> id
                                     end->
                              sig
                                val t_of_sexp :
                                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                              end
                          module Provide_bin_io :
                            functor
                              (Key : sig
                                       val bin_t : id Bin_prot.Type_class.t
                                       val bin_read_t :
                                         id Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> id)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         id Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         id Bin_prot.Size.sizer
                                       val bin_write_t :
                                         id Bin_prot.Write.writer
                                       val bin_writer_t :
                                         id Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_shape_t :
                                  Bin_prot.Shape.t -> Bin_prot.Shape.t
                                val bin_size_t :
                                  ('a, 'a t) Bin_prot.Size.sizer1
                                val bin_write_t :
                                  ('a, 'a t) Bin_prot.Write.writer1
                                val bin_read_t :
                                  ('a, 'a t) Bin_prot.Read.reader1
                                val __bin_read_t__ :
                                  ('a, Monoid.Int.t -> 'a t)
                                  Bin_prot.Read.reader1
                                val bin_writer_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.writer
                                val bin_reader_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.reader
                                val bin_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.t
                              end
                          module Provide_hash :
                            functor
                              (Key : sig
                                       val hash_fold_t :
                                         Base__.Hash.state ->
                                         id -> Base__.Hash.state
                                     end->
                              sig
                                val hash_fold_t :
                                  (Ppx_hash_lib.Std.Hash.state ->
                                   '-> Ppx_hash_lib.Std.Hash.state) ->
                                  Ppx_hash_lib.Std.Hash.state ->
                                  'a t -> Ppx_hash_lib.Std.Hash.state
                              end
                          val t_of_sexp :
                            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                      module Set :
                        sig
                          module Elt :
                            sig
                              type t = id
                              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                              type comparator_witness =
                                  Map.Key.comparator_witness
                              val comparator :
                                (t, comparator_witness)
                                Core_kernel__.Comparator.comparator
                            end
                          module Tree :
                            sig
                              type t =
                                  (id, comparator_witness)
                                  Core_kernel__.Set_intf.Tree.t
                              val compare :
                                t -> t -> Core_kernel__.Import.int
                              type named =
                                  (id, comparator_witness)
                                  Core_kernel__.Set_intf.Tree.Named.t
                              val length : t -> Monoid.Int.t
                              val is_empty : t -> bool
                              val iter :
                                t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                t ->
                                init:'accum ->
                                f:('accum -> id -> 'accum) -> 'accum
                              val fold_result :
                                t ->
                                init:'accum ->
                                f:('accum ->
                                   id -> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val exists : t -> f:(id -> bool) -> bool
                              val for_all : t -> f:(id -> bool) -> bool
                              val count : t -> f:(id -> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                t -> f:(id -> 'sum) -> 'sum
                              val find : t -> f:(id -> bool) -> id Option.t
                              val find_map :
                                t -> f:(id -> 'Option.t) -> 'Option.t
                              val to_list : t -> id List.t
                              val to_array : t -> id array
                              val invariants : t -> bool
                              val mem : t -> id -> bool
                              val add : t -> id -> t
                              val remove : t -> id -> t
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val symmetric_diff :
                                t ->
                                t ->
                                (id, id) Base__.Either.t Base__.Sequence.t
                              val compare_direct : t -> t -> Monoid.Int.t
                              val equal : t -> t -> bool
                              val is_subset : t -> of_:t -> bool
                              val subset : t -> t -> bool
                              module Named :
                                sig
                                  val is_subset :
                                    named ->
                                    of_:named ->
                                    Monoid.Unit.t Base__.Or_error.t
                                  val equal :
                                    named ->
                                    named -> Monoid.Unit.t Base__.Or_error.t
                                end
                              val fold_until :
                                t ->
                                init:'->
                                f:('->
                                   id ->
                                   ('b, 'final)
                                   Base__.Set_intf.Continue_or_stop.t) ->
                                finish:('-> 'final) -> 'final
                              val fold_right :
                                t -> init:'-> f:(id -> '-> 'b) -> 'b
                              val iter2 :
                                t ->
                                t ->
                                f:([ `Both of id * id
                                   | `Left of id
                                   | `Right of id ] -> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val filter : t -> f:(id -> bool) -> t
                              val partition_tf : t -> f:(id -> bool) -> t * t
                              val elements : t -> id List.t
                              val min_elt : t -> id Option.t
                              val min_elt_exn : t -> id
                              val max_elt : t -> id Option.t
                              val max_elt_exn : t -> id
                              val choose : t -> id Option.t
                              val choose_exn : t -> id
                              val split : t -> id -> t * id Option.t * t
                              val group_by :
                                t -> equiv:(id -> id -> bool) -> t List.t
                              val find_exn : t -> f:(id -> bool) -> id
                              val find_index :
                                t -> Monoid.Int.t -> id Option.t
                              val nth : t -> Monoid.Int.t -> id Option.t
                              val remove_index : t -> Monoid.Int.t -> t
                              val to_tree : t -> t
                              val to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t -> id Base__.Sequence.t
                              val merge_to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t ->
                                t ->
                                (id, id)
                                Base__.Set_intf.Merge_to_sequence_element.t
                                Base__.Sequence.t
                              val to_map :
                                t ->
                                f:(id -> 'data) ->
                                (id, 'data, comparator_witness)
                                Core_kernel__.Map.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                t Core_kernel__.Quickcheck.Shrinker.t
                              val empty : t
                              val singleton : id -> t
                              val union_list : t List.t -> t
                              val of_list : id List.t -> t
                              val of_array : id array -> t
                              val of_sorted_array :
                                id array -> t Base__.Or_error.t
                              val of_sorted_array_unchecked : id array -> t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id) -> t
                              val stable_dedup_list : id List.t -> id List.t
                              val map :
                                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                                f:('-> id) -> t
                              val filter_map :
                                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                                f:('-> id Option.t) -> t
                              val of_tree : t -> t
                              val of_hash_set :
                                id Core_kernel__.Hash_set.t -> t
                              val of_hashtbl_keys :
                                (id, 'a) Id.Table.hashtbl -> t
                              val of_map_keys :
                                (id, 'a, comparator_witness)
                                Core_kernel__.Map.t -> t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                t Core_kernel__.Quickcheck.Generator.t
                              module Provide_of_sexp :
                                functor
                                  (Elt : sig
                                           val t_of_sexp :
                                             Ppx_sexp_conv_lib.Sexp.t -> id
                                         end->
                                  sig
                                    val t_of_sexp :
                                      Ppx_sexp_conv_lib.Sexp.t -> t
                                  end
                              val t_of_sexp :
                                Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                              val sexp_of_t :
                                t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                            end
                          type t = (id, comparator_witness) Base.Set.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          type named =
                              (id, comparator_witness)
                              Core_kernel__.Set_intf.Named.t
                          val length : t -> Monoid.Int.t
                          val is_empty : t -> bool
                          val iter :
                            t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id Option.t
                          val find_map :
                            t -> f:(id -> 'Option.t) -> 'Option.t
                          val to_list : t -> id List.t
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> Monoid.Int.t
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          module Named :
                            sig
                              val is_subset :
                                named ->
                                of_:named -> Monoid.Unit.t Base__.Or_error.t
                              val equal :
                                named ->
                                named -> Monoid.Unit.t Base__.Or_error.t
                            end
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'final)
                               Base__.Set_intf.Continue_or_stop.t) ->
                            finish:('-> 'final) -> 'final
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id List.t
                          val min_elt : t -> id Option.t
                          val min_elt_exn : t -> id
                          val max_elt : t -> id Option.t
                          val max_elt_exn : t -> id
                          val choose : t -> id Option.t
                          val choose_exn : t -> id
                          val split : t -> id -> t * id Option.t * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t List.t
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> Monoid.Int.t -> id Option.t
                          val nth : t -> Monoid.Int.t -> id Option.t
                          val remove_index : t -> Monoid.Int.t -> t
                          val to_tree : t -> Tree.t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Base__.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t List.t -> t
                          val of_list : id List.t -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t -> f:(Monoid.Int.t -> id) -> t
                          val stable_dedup_list : id List.t -> id List.t
                          val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                          val of_tree : Tree.t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Id.Table.hashtbl -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness) Core_kernel__.Map.t ->
                            t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> id
                                     end->
                              sig
                                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              end
                          module Provide_bin_io :
                            functor
                              (Elt : sig
                                       val bin_t : id Bin_prot.Type_class.t
                                       val bin_read_t :
                                         id Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> id)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         id Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         id Bin_prot.Size.sizer
                                       val bin_write_t :
                                         id Bin_prot.Write.writer
                                       val bin_writer_t :
                                         id Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_size_t : t Bin_prot.Size.sizer
                                val bin_write_t : t Bin_prot.Write.writer
                                val bin_read_t : t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  (Monoid.Int.t -> t) Bin_prot.Read.reader
                                val bin_shape_t : Bin_prot.Shape.t
                                val bin_writer_t :
                                  t Bin_prot.Type_class.writer
                                val bin_reader_t :
                                  t Bin_prot.Type_class.reader
                                val bin_t : t Bin_prot.Type_class.t
                              end
                          module Provide_hash :
                            functor
                              (Elt : sig
                                       val hash_fold_t :
                                         Base__.Hash.state ->
                                         id -> Base__.Hash.state
                                     end->
                              sig
                                val hash_fold_t :
                                  Ppx_hash_lib.Std.Hash.state ->
                                  t -> Ppx_hash_lib.Std.Hash.state
                                val hash :
                                  t -> Ppx_hash_lib.Std.Hash.hash_value
                              end
                          val t_of_sexp :
                            Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                          val sexp_of_t :
                            t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Monoid.Int.t -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      val hashable : t Core_kernel__.Hashtbl.Hashable.t
                      module Table :
                        sig
                          type key = t
                          type ('a, 'b) hashtbl = ('a, 'b) Id.Table.hashtbl
                          type 'b t = (key, 'b) hashtbl
                          val sexp_of_t :
                            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                            'b t -> Ppx_sexp_conv_lib.Sexp.t
                          type ('a, 'b) t_ = 'b t
                          type 'a key_ = key
                          val hashable :
                            key Core_kernel__.Hashtbl_intf.Hashable.t
                          val invariant :
                            'Base__.Invariant_intf.inv ->
                            'a t Base__.Invariant_intf.inv
                          val create :
                            (key, 'b, Monoid.Unit.t -> 'b t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist :
                            (key, 'b,
                             (key * 'b) List.t ->
                             [ `Duplicate_key of key | `Ok of 'b t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_report_all_dups :
                            (key, 'b,
                             (key * 'b) List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_or_error :
                            (key, 'b,
                             (key * 'b) List.t -> 'b t Base__.Or_error.t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_exn :
                            (key, 'b, (key * 'b) List.t -> 'b t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_multi :
                            (key, 'List.t,
                             (key * 'b) List.t -> 'List.t t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_mapped :
                            (key, 'b,
                             get_key:('-> key) ->
                             get_data:('-> 'b) ->
                             'List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_with_key :
                            (key, 'r,
                             get_key:('-> key) ->
                             'List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_with_key_or_error :
                            (key, 'r,
                             get_key:('-> key) ->
                             'List.t -> 'r t Base__.Or_error.t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_with_key_exn :
                            (key, 'r,
                             get_key:('-> key) -> 'List.t -> 'r t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val group :
                            (key, 'b,
                             get_key:('-> key) ->
                             get_data:('-> 'b) ->
                             combine:('-> '-> 'b) -> 'List.t -> 'b t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                          val clear : 'a t -> Monoid.Unit.t
                          val copy : 'b t -> 'b t
                          val fold :
                            'b t ->
                            init:'->
                            f:(key:key -> data:'-> '-> 'c) -> 'c
                          val iter_keys :
                            'a t -> f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'b t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'b t ->
                            f:(key:key -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val existsi :
                            'b t -> f:(key:key -> data:'-> bool) -> bool
                          val exists : 'b t -> f:('-> bool) -> bool
                          val for_alli :
                            'b t -> f:(key:key -> data:'-> bool) -> bool
                          val for_all : 'b t -> f:('-> bool) -> bool
                          val counti :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> Monoid.Int.t
                          val count : 'b t -> f:('-> bool) -> Monoid.Int.t
                          val length : 'a t -> Monoid.Int.t
                          val is_empty : 'a t -> bool
                          val mem : 'a t -> key -> bool
                          val remove : 'a t -> key -> Monoid.Unit.t
                          val set :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val add :
                            'b t ->
                            key:key -> data:'-> [ `Duplicate | `Ok ]
                          val add_exn :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val change :
                            'b t ->
                            key ->
                            f:('Option.t -> 'Option.t) -> Monoid.Unit.t
                          val update :
                            'b t ->
                            key -> f:('Option.t -> 'b) -> Monoid.Unit.t
                          val map : 'b t -> f:('-> 'c) -> 'c t
                          val mapi :
                            'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                          val filter_map :
                            'b t -> f:('-> 'Option.t) -> 'c t
                          val filter_mapi :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) -> 'c t
                          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                          val filter : 'b t -> f:('-> bool) -> 'b t
                          val filteri :
                            'b t -> f:(key:key -> data:'-> bool) -> 'b t
                          val partition_map :
                            'b t ->
                            f:('-> [ `Fst of '| `Snd of 'd ]) ->
                            'c t * 'd t
                          val partition_mapi :
                            'b t ->
                            f:(key:key ->
                               data:'-> [ `Fst of '| `Snd of 'd ]) ->
                            'c t * 'd t
                          val partition_tf :
                            'b t -> f:('-> bool) -> 'b t * 'b t
                          val partitioni_tf :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> 'b t * 'b t
                          val find_or_add :
                            'b t ->
                            key -> default:(Monoid.Unit.t -> 'b) -> 'b
                          val findi_or_add :
                            'b t -> key -> default:(key -> 'b) -> 'b
                          val find : 'b t -> key -> 'Option.t
                          val find_exn : 'b t -> key -> 'b
                          val find_and_call :
                            'b t ->
                            key ->
                            if_found:('-> 'c) ->
                            if_not_found:(key -> 'c) -> 'c
                          val findi_and_call :
                            'b t ->
                            key ->
                            if_found:(key:key -> data:'-> 'c) ->
                            if_not_found:(key -> 'c) -> 'c
                          val find_and_remove : 'b t -> key -> 'Option.t
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:key ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          type 'a merge_into_action = Remove | Set_to of 'a
                          val merge_into :
                            src:'a t ->
                            dst:'b t ->
                            f:(key:key ->
                               '-> 'Option.t -> 'b merge_into_action) ->
                            Monoid.Unit.t
                          val keys : 'a t -> key List.t
                          val data : 'b t -> 'List.t
                          val filter_keys_inplace :
                            'a t -> f:(key -> bool) -> Monoid.Unit.t
                          val filter_inplace :
                            'b t -> f:('-> bool) -> Monoid.Unit.t
                          val filteri_inplace :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> Monoid.Unit.t
                          val map_inplace :
                            'b t -> f:('-> 'b) -> Monoid.Unit.t
                          val mapi_inplace :
                            'b t ->
                            f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                          val filter_map_inplace :
                            'b t -> f:('-> 'Option.t) -> Monoid.Unit.t
                          val filter_mapi_inplace :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) ->
                            Monoid.Unit.t
                          val equal :
                            'b t -> 'b t -> ('-> '-> bool) -> bool
                          val similar :
                            'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                          val to_alist : 'b t -> (key * 'b) List.t
                          val validate :
                            name:(key -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'b t Base__.Validate.check
                          val incr :
                            ?by:Monoid.Int.t ->
                            ?remove_if_zero:bool ->
                            Monoid.Int.t t -> key -> Monoid.Unit.t
                          val decr :
                            ?by:Monoid.Int.t ->
                            ?remove_if_zero:bool ->
                            Monoid.Int.t t -> key -> Monoid.Unit.t
                          val add_multi :
                            'List.t t ->
                            key:key -> data:'-> Monoid.Unit.t
                          val remove_multi :
                            'List.t t -> key -> Monoid.Unit.t
                          val find_multi : 'List.t t -> key -> 'List.t
                          module Provide_of_sexp :
                            functor
                              (Key : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> key
                                     end->
                              sig
                                val t_of_sexp :
                                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                              end
                          module Provide_bin_io :
                            functor
                              (Key : sig
                                       val bin_t : key Bin_prot.Type_class.t
                                       val bin_read_t :
                                         key Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> key)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         key Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         key Bin_prot.Size.sizer
                                       val bin_write_t :
                                         key Bin_prot.Write.writer
                                       val bin_writer_t :
                                         key Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_t :
                                  'Bin_prot.Type_class.t ->
                                  'a t Bin_prot.Type_class.t
                                val bin_read_t :
                                  'Bin_prot.Read.reader ->
                                  'a t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  'Bin_prot.Read.reader ->
                                  (Core_kernel__.Import.int -> 'a t)
                                  Bin_prot.Read.reader
                                val bin_reader_t :
                                  'Bin_prot.Type_class.reader ->
                                  'a t Bin_prot.Type_class.reader
                                val bin_size_t :
                                  'Bin_prot.Size.sizer ->
                                  'a t Bin_prot.Size.sizer
                                val bin_write_t :
                                  'Bin_prot.Write.writer ->
                                  'a t Bin_prot.Write.writer
                                val bin_writer_t :
                                  'Bin_prot.Type_class.writer ->
                                  'a t Bin_prot.Type_class.writer
                                val bin_shape_t :
                                  Bin_prot.Shape.t -> Bin_prot.Shape.t
                              end
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                      module Hash_set :
                        sig
                          type elt = t
                          type t = elt Core_kernel__.Hash_set.t
                          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                          type 'a t_ = t
                          type 'a elt_ = elt
                          val create :
                            ('a, Monoid.Unit.t -> t)
                            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                          val of_list :
                            ('a, elt List.t -> t)
                            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                          module Provide_of_sexp :
                            functor
                              (X : sig
                                     val t_of_sexp :
                                       Ppx_sexp_conv_lib.Sexp.t -> elt
                                   end->
                              sig
                                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              end
                          module Provide_bin_io :
                            functor
                              (X : sig
                                     val bin_t : elt Bin_prot.Type_class.t
                                     val bin_read_t :
                                       elt Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> elt)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       elt Bin_prot.Type_class.reader
                                     val bin_size_t : elt Bin_prot.Size.sizer
                                     val bin_write_t :
                                       elt Bin_prot.Write.writer
                                     val bin_writer_t :
                                       elt Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                              sig
                                val bin_t : t Bin_prot.Type_class.t
                                val bin_read_t : t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  (Core_kernel__.Import.int -> t)
                                  Bin_prot.Read.reader
                                val bin_reader_t :
                                  t Bin_prot.Type_class.reader
                                val bin_size_t : t Bin_prot.Size.sizer
                                val bin_write_t : t Bin_prot.Write.writer
                                val bin_writer_t :
                                  t Bin_prot.Type_class.writer
                                val bin_shape_t : Bin_prot.Shape.t
                              end
                          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Monoid.Int.t -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                      module Hash_queue :
                        sig
                          module Key :
                            sig
                              type t = id
                              val compare : t -> t -> Monoid.Int.t
                              val sexp_of_t :
                                t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                              val hash : t -> Monoid.Int.t
                            end
                          type 'a t
                          val sexp_of_t :
                            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                            'a t -> Ppx_sexp_conv_lib.Sexp.t
                          val length : 'a t -> Monoid.Int.t
                          val is_empty : 'a t -> bool
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            'a t ->
                            init:'accum ->
                            f:('accum -> '-> 'accum) -> 'accum
                          val fold_result :
                            'a t ->
                            init:'accum ->
                            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val fold_until :
                            'a t ->
                            init:'accum ->
                            f:('accum ->
                               '->
                               ('accum, 'final)
                               Base__.Container_intf.Continue_or_stop.t) ->
                            finish:('accum -> 'final) -> 'final
                          val exists : 'a t -> f:('-> bool) -> bool
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            'a t -> f:('-> 'sum) -> 'sum
                          val find : 'a t -> f:('-> bool) -> 'Option.t
                          val find_map :
                            'a t -> f:('-> 'Option.t) -> 'Option.t
                          val to_list : 'a t -> 'List.t
                          val to_array : 'a t -> 'a array
                          val min_elt :
                            'a t ->
                            compare:('-> '-> Monoid.Int.t) -> 'Option.t
                          val max_elt :
                            'a t ->
                            compare:('-> '-> Monoid.Int.t) -> 'Option.t
                          val invariant : 'a t -> Core_kernel__.Import.unit
                          val create :
                            ?growth_allowed:Core_kernel__.Import.bool ->
                            ?size:Core_kernel__.Import.int ->
                            Core_kernel__.Import.unit -> 'a t
                          val clear : 'a t -> Core_kernel__.Import.unit
                          val mem : 'a t -> id -> Core_kernel__.Import.bool
                          val lookup :
                            'a t -> id -> 'Core_kernel__.Import.option
                          val lookup_exn : 'a t -> id -> 'a
                          val enqueue :
                            'a t ->
                            id -> '-> [ `Key_already_present | `Ok ]
                          val enqueue_exn :
                            'a t -> id -> '-> Core_kernel__.Import.unit
                          val lookup_and_move_to_back :
                            'a t -> id -> 'Core_kernel__.Import.option
                          val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                          val first : 'a t -> 'Core_kernel__.Import.option
                          val first_with_key :
                            'a t -> (id * 'a) Core_kernel__.Import.option
                          val keys : 'a t -> id Core_kernel__.Import.list
                          val dequeue :
                            'a t -> 'Core_kernel__.Import.option
                          val dequeue_exn : 'a t -> 'a
                          val dequeue_with_key :
                            'a t -> (id * 'a) Core_kernel__.Import.option
                          val dequeue_with_key_exn : 'a t -> id * 'a
                          val dequeue_all :
                            'a t ->
                            f:('-> Core_kernel__.Import.unit) ->
                            Core_kernel__.Import.unit
                          val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                          val remove_exn :
                            'a t -> id -> Core_kernel__.Import.unit
                          val replace :
                            'a t -> id -> '-> [ `No_such_key | `Ok ]
                          val replace_exn :
                            'a t -> id -> '-> Core_kernel__.Import.unit
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                            Core_kernel__.Import.unit
                          val foldi :
                            'a t ->
                            init:'->
                            f:('-> key:id -> data:'-> 'b) -> 'b
                        end
                    end
                  val global : Monads.Std.Monad.State.Multi.S.id
                  val fork : unit -> unit t
                  val switch : Monads.Std.Monad.State.Multi.S.id -> unit t
                  val parent : unit -> Monads.Std.Monad.State.Multi.S.id t
                  val ancestor :
                    Monads.Std.Monad.State.Multi.S.id list ->
                    Monads.Std.Monad.State.Multi.S.id t
                  val current : unit -> Monads.Std.Monad.State.Multi.S.id t
                  val kill : Monads.Std.Monad.State.Multi.S.id -> unit t
                  val forks :
                    unit ->
                    Monads.Std.Monad.State.Multi.S.id Core_kernel.Sequence.t
                    t
                  val status :
                    Monads.Std.Monad.State.Multi.S.id ->
                    Monads.Std.Monad.State.Multi.status t
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  type env
                  val put : env -> Monoid.Unit.t t
                  val get : Monoid.Unit.t -> env t
                  val gets : (env -> 'r) -> 'r t
                  val update : (env -> env) -> Monoid.Unit.t t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type 'a m
                  type ('a, 'e) e
                  type id
                  module Id :
                    sig
                      type t = id
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                      val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                      val of_string : Monoid.String.t -> t
                      val to_string : t -> Monoid.String.t
                      val pp : Base__.Formatter.t -> t -> Monoid.Unit.t
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> Monoid.Int.t
                      val min : t -> t -> t
                      val max : t -> t -> t
                      val ascending : t -> t -> Monoid.Int.t
                      val descending : t -> t -> Monoid.Int.t
                      val between : t -> low:t -> high:t -> bool
                      val clamp_exn : t -> min:t -> max:t -> t
                      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                      type comparator_witness
                      val validate_lbound :
                        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      val validate_ubound :
                        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      val validate_bound :
                        min:t Base__.Maybe_bound.t ->
                        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      module Replace_polymorphic_compare :
                        sig
                          val ( >= ) : t -> t -> bool
                          val ( <= ) : t -> t -> bool
                          val ( = ) : t -> t -> bool
                          val ( > ) : t -> t -> bool
                          val ( < ) : t -> t -> bool
                          val ( <> ) : t -> t -> bool
                          val equal : t -> t -> bool
                          val compare : t -> t -> Monoid.Int.t
                          val min : t -> t -> t
                          val max : t -> t -> t
                        end
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                      module Map :
                        sig
                          module Key :
                            sig
                              type t = id
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                              type comparator_witness = comparator_witness
                              val comparator :
                                (t, comparator_witness)
                                Core_kernel__.Comparator.comparator
                            end
                          module Tree :
                            sig
                              type 'a t =
                                  (id, 'a, comparator_witness)
                                  Core_kernel__.Map_intf.Tree.t
                              val empty : 'a t
                              val singleton : id -> '-> 'a t
                              val of_alist :
                                (id * 'a) List.t ->
                                [ `Duplicate_key of id | `Ok of 'a t ]
                              val of_alist_or_error :
                                (id * 'a) List.t -> 'a t Base__.Or_error.t
                              val of_alist_exn : (id * 'a) List.t -> 'a t
                              val of_alist_multi :
                                (id * 'a) List.t -> 'List.t t
                              val of_alist_fold :
                                (id * 'a) List.t ->
                                init:'-> f:('-> '-> 'b) -> 'b t
                              val of_alist_reduce :
                                (id * 'a) List.t ->
                                f:('-> '-> 'a) -> 'a t
                              val of_sorted_array :
                                (id * 'a) array -> 'a t Base__.Or_error.t
                              val of_sorted_array_unchecked :
                                (id * 'a) array -> 'a t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id * 'a) -> 'a t
                              val of_increasing_sequence :
                                (id * 'a) Base__.Sequence.t ->
                                'a t Base__.Or_error.t
                              val of_iteri :
                                iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                       Monoid.Unit.t) ->
                                [ `Duplicate_key of id | `Ok of 'v t ]
                              val of_tree : 'a t -> 'a t
                              val of_hashtbl_exn :
                                (id, 'a) Id.Table.hashtbl -> 'a t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                'Core_kernel__.Quickcheck.Generator.t ->
                                'a t Core_kernel__.Quickcheck.Generator.t
                              val invariants : 'a t -> bool
                              val is_empty : 'a t -> bool
                              val length : 'a t -> Monoid.Int.t
                              val add :
                                'a t ->
                                key:id ->
                                data:'->
                                'a t Base__.Map_intf.Or_duplicate.t
                              val add_exn : 'a t -> key:id -> data:'-> 'a t
                              val set : 'a t -> key:id -> data:'-> 'a t
                              val add_multi :
                                'List.t t ->
                                key:id -> data:'-> 'List.t t
                              val remove_multi :
                                'List.t t -> id -> 'List.t t
                              val find_multi : 'List.t t -> id -> 'List.t
                              val change :
                                'a t ->
                                id -> f:('Option.t -> 'Option.t) -> 'a t
                              val update :
                                'a t -> id -> f:('Option.t -> 'a) -> 'a t
                              val find : 'a t -> id -> 'Option.t
                              val find_exn : 'a t -> id -> 'a
                              val remove : 'a t -> id -> 'a t
                              val mem : 'a t -> id -> bool
                              val iter_keys :
                                'a t ->
                                f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'a t ->
                                f:(key:id -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter2 :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val mapi :
                                'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                              val fold :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold_right :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold2 :
                                'a t ->
                                'b t ->
                                init:'->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   '-> 'c) ->
                                'c
                              val filter_keys :
                                'a t -> f:(id -> bool) -> 'a t
                              val filter : 'a t -> f:('-> bool) -> 'a t
                              val filteri :
                                'a t -> f:(key:id -> data:'-> bool) -> 'a t
                              val filter_map :
                                'a t -> f:('-> 'Option.t) -> 'b t
                              val filter_mapi :
                                'a t ->
                                f:(key:id -> data:'-> 'Option.t) -> 'b t
                              val partition_mapi :
                                'a t ->
                                f:(key:id ->
                                   data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partition_map :
                                'a t ->
                                f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partitioni_tf :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> 'a t * 'a t
                              val partition_tf :
                                'a t -> f:('-> bool) -> 'a t * 'a t
                              val compare_direct :
                                ('-> '-> Monoid.Int.t) ->
                                'a t -> 'a t -> Monoid.Int.t
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val keys : 'a t -> id List.t
                              val data : 'a t -> 'List.t
                              val to_alist :
                                ?key_order:[ `Decreasing | `Increasing ] ->
                                'a t -> (id * 'a) List.t
                              val validate :
                                name:(id -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'a t Base__.Validate.check
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              val symmetric_diff :
                                'a t ->
                                'a t ->
                                data_equal:('-> '-> bool) ->
                                (id, 'a)
                                Base__.Map_intf.Symmetric_diff_element.t
                                Base__.Sequence.t
                              val min_elt : 'a t -> (id * 'a) Option.t
                              val min_elt_exn : 'a t -> id * 'a
                              val max_elt : 'a t -> (id * 'a) Option.t
                              val max_elt_exn : 'a t -> id * 'a
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val for_alli :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val exists : 'a t -> f:('-> bool) -> bool
                              val existsi :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val counti :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> Monoid.Int.t
                              val split :
                                'a t ->
                                id -> 'a t * (id * 'a) Option.t * 'a t
                              val append :
                                lower_part:'a t ->
                                upper_part:'a t ->
                                [ `Ok of 'a t | `Overlapping_key_ranges ]
                              val subrange :
                                'a t ->
                                lower_bound:id Base__.Maybe_bound.t ->
                                upper_bound:id Base__.Maybe_bound.t -> 'a t
                              val fold_range_inclusive :
                                'a t ->
                                min:id ->
                                max:id ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val range_to_alist :
                                'a t -> min:id -> max:id -> (id * 'a) List.t
                              val closest_key :
                                'a t ->
                                [ `Greater_or_equal_to
                                | `Greater_than
                                | `Less_or_equal_to
                                | `Less_than ] -> id -> (id * 'a) Option.t
                              val nth :
                                'a t -> Monoid.Int.t -> (id * 'a) Option.t
                              val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                              val rank : 'a t -> id -> Monoid.Int.t Option.t
                              val to_tree : 'a t -> 'a t
                              val to_sequence :
                                ?order:[ `Decreasing_key | `Increasing_key ] ->
                                ?keys_greater_or_equal_to:id ->
                                ?keys_less_or_equal_to:id ->
                                'a t -> (id * 'a) Base__.Sequence.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                'Core_kernel__.Quickcheck.Observer.t ->
                                'v t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                'Core_kernel__.Quickcheck.Shrinker.t ->
                                'v t Core_kernel__.Quickcheck.Shrinker.t
                              module Provide_of_sexp :
                                functor
                                  (K : sig
                                         val t_of_sexp :
                                           Ppx_sexp_conv_lib.Sexp.t -> id
                                       end->
                                  sig
                                    val t_of_sexp :
                                      (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__017_) ->
                                      Ppx_sexp_conv_lib.Sexp.t ->
                                      'v_x__017_ t
                                  end
                              val t_of_sexp :
                                (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                                Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                              val sexp_of_t :
                                ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                                'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                            end
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Map_intf.Map.t
                          val compare :
                            ('-> '-> Core_kernel__.Import.int) ->
                            'a t -> 'a t -> Core_kernel__.Import.int
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) List.t ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) List.t -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) List.t -> 'a t
                          val of_alist_multi :
                            (id * 'a) List.t -> 'List.t t
                          val of_alist_fold :
                            (id * 'a) List.t ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t ->
                            f:(Monoid.Int.t -> id * 'a) -> 'a t
                          val of_increasing_sequence :
                            (id * 'a) Base__.Sequence.t ->
                            'a t Base__.Or_error.t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                   Monoid.Unit.t) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'Tree.t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Id.Table.hashtbl -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> Monoid.Int.t
                          val add :
                            'a t ->
                            key:id ->
                            data:'-> 'a t Base__.Map_intf.Or_duplicate.t
                          val add_exn : 'a t -> key:id -> data:'-> 'a t
                          val set : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'List.t t -> key:id -> data:'-> 'List.t t
                          val remove_multi : 'List.t t -> id -> 'List.t t
                          val find_multi : 'List.t t -> id -> 'List.t
                          val change :
                            'a t ->
                            id -> f:('Option.t -> 'Option.t) -> 'a t
                          val update :
                            'a t -> id -> f:('Option.t -> 'a) -> 'a t
                          val find : 'a t -> id -> 'Option.t
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys :
                            'a t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'Option.t) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'Option.t) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> Monoid.Int.t) ->
                            'a t -> 'a t -> Monoid.Int.t
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id List.t
                          val data : 'a t -> 'List.t
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) List.t
                          val validate :
                            name:(id -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a) Base__.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) Option.t
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) Option.t
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val counti :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> Monoid.Int.t
                          val split :
                            'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) List.t
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) Option.t
                          val nth :
                            'a t -> Monoid.Int.t -> (id * 'a) Option.t
                          val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                          val rank : 'a t -> id -> Monoid.Int.t Option.t
                          val to_tree : 'a t -> 'Tree.t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (Key : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> id
                                     end->
                              sig
                                val t_of_sexp :
                                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_) ->
                                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__018_ t
                              end
                          module Provide_bin_io :
                            functor
                              (Key : sig
                                       val bin_t : id Bin_prot.Type_class.t
                                       val bin_read_t :
                                         id Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> id)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         id Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         id Bin_prot.Size.sizer
                                       val bin_write_t :
                                         id Bin_prot.Write.writer
                                       val bin_writer_t :
                                         id Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_shape_t :
                                  Bin_prot.Shape.t -> Bin_prot.Shape.t
                                val bin_size_t :
                                  ('a, 'a t) Bin_prot.Size.sizer1
                                val bin_write_t :
                                  ('a, 'a t) Bin_prot.Write.writer1
                                val bin_read_t :
                                  ('a, 'a t) Bin_prot.Read.reader1
                                val __bin_read_t__ :
                                  ('a, Monoid.Int.t -> 'a t)
                                  Bin_prot.Read.reader1
                                val bin_writer_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.writer
                                val bin_reader_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.reader
                                val bin_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.t
                              end
                          module Provide_hash :
                            functor
                              (Key : sig
                                       val hash_fold_t :
                                         Base__.Hash.state ->
                                         id -> Base__.Hash.state
                                     end->
                              sig
                                val hash_fold_t :
                                  (Ppx_hash_lib.Std.Hash.state ->
                                   '-> Ppx_hash_lib.Std.Hash.state) ->
                                  Ppx_hash_lib.Std.Hash.state ->
                                  'a t -> Ppx_hash_lib.Std.Hash.state
                              end
                          val t_of_sexp :
                            (Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
                            Base__.Ppx_sexp_conv_lib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Ppx_sexp_conv_lib.Sexp.t) ->
                            'a t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                      module Set :
                        sig
                          module Elt :
                            sig
                              type t = id
                              val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                              type comparator_witness =
                                  Map.Key.comparator_witness
                              val comparator :
                                (t, comparator_witness)
                                Core_kernel__.Comparator.comparator
                            end
                          module Tree :
                            sig
                              type t =
                                  (id, comparator_witness)
                                  Core_kernel__.Set_intf.Tree.t
                              val compare :
                                t -> t -> Core_kernel__.Import.int
                              type named =
                                  (id, comparator_witness)
                                  Core_kernel__.Set_intf.Tree.Named.t
                              val length : t -> Monoid.Int.t
                              val is_empty : t -> bool
                              val iter :
                                t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                t ->
                                init:'accum ->
                                f:('accum -> id -> 'accum) -> 'accum
                              val fold_result :
                                t ->
                                init:'accum ->
                                f:('accum ->
                                   id -> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val exists : t -> f:(id -> bool) -> bool
                              val for_all : t -> f:(id -> bool) -> bool
                              val count : t -> f:(id -> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                t -> f:(id -> 'sum) -> 'sum
                              val find : t -> f:(id -> bool) -> id Option.t
                              val find_map :
                                t -> f:(id -> 'Option.t) -> 'Option.t
                              val to_list : t -> id List.t
                              val to_array : t -> id array
                              val invariants : t -> bool
                              val mem : t -> id -> bool
                              val add : t -> id -> t
                              val remove : t -> id -> t
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val symmetric_diff :
                                t ->
                                t ->
                                (id, id) Base__.Either.t Base__.Sequence.t
                              val compare_direct : t -> t -> Monoid.Int.t
                              val equal : t -> t -> bool
                              val is_subset : t -> of_:t -> bool
                              val subset : t -> t -> bool
                              module Named :
                                sig
                                  val is_subset :
                                    named ->
                                    of_:named ->
                                    Monoid.Unit.t Base__.Or_error.t
                                  val equal :
                                    named ->
                                    named -> Monoid.Unit.t Base__.Or_error.t
                                end
                              val fold_until :
                                t ->
                                init:'->
                                f:('->
                                   id ->
                                   ('b, 'final)
                                   Base__.Set_intf.Continue_or_stop.t) ->
                                finish:('-> 'final) -> 'final
                              val fold_right :
                                t -> init:'-> f:(id -> '-> 'b) -> 'b
                              val iter2 :
                                t ->
                                t ->
                                f:([ `Both of id * id
                                   | `Left of id
                                   | `Right of id ] -> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val filter : t -> f:(id -> bool) -> t
                              val partition_tf : t -> f:(id -> bool) -> t * t
                              val elements : t -> id List.t
                              val min_elt : t -> id Option.t
                              val min_elt_exn : t -> id
                              val max_elt : t -> id Option.t
                              val max_elt_exn : t -> id
                              val choose : t -> id Option.t
                              val choose_exn : t -> id
                              val split : t -> id -> t * id Option.t * t
                              val group_by :
                                t -> equiv:(id -> id -> bool) -> t List.t
                              val find_exn : t -> f:(id -> bool) -> id
                              val find_index :
                                t -> Monoid.Int.t -> id Option.t
                              val nth : t -> Monoid.Int.t -> id Option.t
                              val remove_index : t -> Monoid.Int.t -> t
                              val to_tree : t -> t
                              val to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t -> id Base__.Sequence.t
                              val merge_to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t ->
                                t ->
                                (id, id)
                                Base__.Set_intf.Merge_to_sequence_element.t
                                Base__.Sequence.t
                              val to_map :
                                t ->
                                f:(id -> 'data) ->
                                (id, 'data, comparator_witness)
                                Core_kernel__.Map.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                t Core_kernel__.Quickcheck.Shrinker.t
                              val empty : t
                              val singleton : id -> t
                              val union_list : t List.t -> t
                              val of_list : id List.t -> t
                              val of_array : id array -> t
                              val of_sorted_array :
                                id array -> t Base__.Or_error.t
                              val of_sorted_array_unchecked : id array -> t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id) -> t
                              val stable_dedup_list : id List.t -> id List.t
                              val map :
                                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                                f:('-> id) -> t
                              val filter_map :
                                ('a, 'b) Core_kernel__.Set_intf.Tree.t ->
                                f:('-> id Option.t) -> t
                              val of_tree : t -> t
                              val of_hash_set :
                                id Core_kernel__.Hash_set.t -> t
                              val of_hashtbl_keys :
                                (id, 'a) Id.Table.hashtbl -> t
                              val of_map_keys :
                                (id, 'a, comparator_witness)
                                Core_kernel__.Map.t -> t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                t Core_kernel__.Quickcheck.Generator.t
                              module Provide_of_sexp :
                                functor
                                  (Elt : sig
                                           val t_of_sexp :
                                             Ppx_sexp_conv_lib.Sexp.t -> id
                                         end->
                                  sig
                                    val t_of_sexp :
                                      Ppx_sexp_conv_lib.Sexp.t -> t
                                  end
                              val t_of_sexp :
                                Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                              val sexp_of_t :
                                t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                            end
                          type t = (id, comparator_witness) Base.Set.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          type named =
                              (id, comparator_witness)
                              Core_kernel__.Set_intf.Named.t
                          val length : t -> Monoid.Int.t
                          val is_empty : t -> bool
                          val iter :
                            t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id Option.t
                          val find_map :
                            t -> f:(id -> 'Option.t) -> 'Option.t
                          val to_list : t -> id List.t
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> Monoid.Int.t
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          module Named :
                            sig
                              val is_subset :
                                named ->
                                of_:named -> Monoid.Unit.t Base__.Or_error.t
                              val equal :
                                named ->
                                named -> Monoid.Unit.t Base__.Or_error.t
                            end
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'final)
                               Base__.Set_intf.Continue_or_stop.t) ->
                            finish:('-> 'final) -> 'final
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id List.t
                          val min_elt : t -> id Option.t
                          val min_elt_exn : t -> id
                          val max_elt : t -> id Option.t
                          val max_elt_exn : t -> id
                          val choose : t -> id Option.t
                          val choose_exn : t -> id
                          val split : t -> id -> t * id Option.t * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t List.t
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> Monoid.Int.t -> id Option.t
                          val nth : t -> Monoid.Int.t -> id Option.t
                          val remove_index : t -> Monoid.Int.t -> t
                          val to_tree : t -> Tree.t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Base__.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t List.t -> t
                          val of_list : id List.t -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t -> f:(Monoid.Int.t -> id) -> t
                          val stable_dedup_list : id List.t -> id List.t
                          val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                          val of_tree : Tree.t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Id.Table.hashtbl -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness) Core_kernel__.Map.t ->
                            t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> id
                                     end->
                              sig
                                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              end
                          module Provide_bin_io :
                            functor
                              (Elt : sig
                                       val bin_t : id Bin_prot.Type_class.t
                                       val bin_read_t :
                                         id Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> id)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         id Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         id Bin_prot.Size.sizer
                                       val bin_write_t :
                                         id Bin_prot.Write.writer
                                       val bin_writer_t :
                                         id Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_size_t : t Bin_prot.Size.sizer
                                val bin_write_t : t Bin_prot.Write.writer
                                val bin_read_t : t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  (Monoid.Int.t -> t) Bin_prot.Read.reader
                                val bin_shape_t : Bin_prot.Shape.t
                                val bin_writer_t :
                                  t Bin_prot.Type_class.writer
                                val bin_reader_t :
                                  t Bin_prot.Type_class.reader
                                val bin_t : t Bin_prot.Type_class.t
                              end
                          module Provide_hash :
                            functor
                              (Elt : sig
                                       val hash_fold_t :
                                         Base__.Hash.state ->
                                         id -> Base__.Hash.state
                                     end->
                              sig
                                val hash_fold_t :
                                  Ppx_hash_lib.Std.Hash.state ->
                                  t -> Ppx_hash_lib.Std.Hash.state
                                val hash :
                                  t -> Ppx_hash_lib.Std.Hash.hash_value
                              end
                          val t_of_sexp :
                            Base__.Ppx_sexp_conv_lib.Sexp.t -> t
                          val sexp_of_t :
                            t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Monoid.Int.t -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                      val hash_fold_t :
                        Ppx_hash_lib.Std.Hash.state ->
                        t -> Ppx_hash_lib.Std.Hash.state
                      val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      val hashable : t Core_kernel__.Hashtbl.Hashable.t
                      module Table :
                        sig
                          type key = t
                          type ('a, 'b) hashtbl = ('a, 'b) Id.Table.hashtbl
                          type 'b t = (key, 'b) hashtbl
                          val sexp_of_t :
                            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                            'b t -> Ppx_sexp_conv_lib.Sexp.t
                          type ('a, 'b) t_ = 'b t
                          type 'a key_ = key
                          val hashable :
                            key Core_kernel__.Hashtbl_intf.Hashable.t
                          val invariant :
                            'Base__.Invariant_intf.inv ->
                            'a t Base__.Invariant_intf.inv
                          val create :
                            (key, 'b, Monoid.Unit.t -> 'b t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist :
                            (key, 'b,
                             (key * 'b) List.t ->
                             [ `Duplicate_key of key | `Ok of 'b t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_report_all_dups :
                            (key, 'b,
                             (key * 'b) List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_or_error :
                            (key, 'b,
                             (key * 'b) List.t -> 'b t Base__.Or_error.t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_exn :
                            (key, 'b, (key * 'b) List.t -> 'b t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val of_alist_multi :
                            (key, 'List.t,
                             (key * 'b) List.t -> 'List.t t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_mapped :
                            (key, 'b,
                             get_key:('-> key) ->
                             get_data:('-> 'b) ->
                             'List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_with_key :
                            (key, 'r,
                             get_key:('-> key) ->
                             'List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_with_key_or_error :
                            (key, 'r,
                             get_key:('-> key) ->
                             'List.t -> 'r t Base__.Or_error.t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val create_with_key_exn :
                            (key, 'r,
                             get_key:('-> key) -> 'List.t -> 'r t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val group :
                            (key, 'b,
                             get_key:('-> key) ->
                             get_data:('-> 'b) ->
                             combine:('-> '-> 'b) -> 'List.t -> 'b t)
                            Core_kernel__.Hashtbl_intf.create_options_without_hashable
                          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                          val clear : 'a t -> Monoid.Unit.t
                          val copy : 'b t -> 'b t
                          val fold :
                            'b t ->
                            init:'->
                            f:(key:key -> data:'-> '-> 'c) -> 'c
                          val iter_keys :
                            'a t -> f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'b t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'b t ->
                            f:(key:key -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val existsi :
                            'b t -> f:(key:key -> data:'-> bool) -> bool
                          val exists : 'b t -> f:('-> bool) -> bool
                          val for_alli :
                            'b t -> f:(key:key -> data:'-> bool) -> bool
                          val for_all : 'b t -> f:('-> bool) -> bool
                          val counti :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> Monoid.Int.t
                          val count : 'b t -> f:('-> bool) -> Monoid.Int.t
                          val length : 'a t -> Monoid.Int.t
                          val is_empty : 'a t -> bool
                          val mem : 'a t -> key -> bool
                          val remove : 'a t -> key -> Monoid.Unit.t
                          val set :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val add :
                            'b t ->
                            key:key -> data:'-> [ `Duplicate | `Ok ]
                          val add_exn :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val change :
                            'b t ->
                            key ->
                            f:('Option.t -> 'Option.t) -> Monoid.Unit.t
                          val update :
                            'b t ->
                            key -> f:('Option.t -> 'b) -> Monoid.Unit.t
                          val map : 'b t -> f:('-> 'c) -> 'c t
                          val mapi :
                            'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                          val filter_map :
                            'b t -> f:('-> 'Option.t) -> 'c t
                          val filter_mapi :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) -> 'c t
                          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                          val filter : 'b t -> f:('-> bool) -> 'b t
                          val filteri :
                            'b t -> f:(key:key -> data:'-> bool) -> 'b t
                          val partition_map :
                            'b t ->
                            f:('-> [ `Fst of '| `Snd of 'd ]) ->
                            'c t * 'd t
                          val partition_mapi :
                            'b t ->
                            f:(key:key ->
                               data:'-> [ `Fst of '| `Snd of 'd ]) ->
                            'c t * 'd t
                          val partition_tf :
                            'b t -> f:('-> bool) -> 'b t * 'b t
                          val partitioni_tf :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> 'b t * 'b t
                          val find_or_add :
                            'b t ->
                            key -> default:(Monoid.Unit.t -> 'b) -> 'b
                          val findi_or_add :
                            'b t -> key -> default:(key -> 'b) -> 'b
                          val find : 'b t -> key -> 'Option.t
                          val find_exn : 'b t -> key -> 'b
                          val find_and_call :
                            'b t ->
                            key ->
                            if_found:('-> 'c) ->
                            if_not_found:(key -> 'c) -> 'c
                          val findi_and_call :
                            'b t ->
                            key ->
                            if_found:(key:key -> data:'-> 'c) ->
                            if_not_found:(key -> 'c) -> 'c
                          val find_and_remove : 'b t -> key -> 'Option.t
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:key ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          type 'a merge_into_action = Remove | Set_to of 'a
                          val merge_into :
                            src:'a t ->
                            dst:'b t ->
                            f:(key:key ->
                               '-> 'Option.t -> 'b merge_into_action) ->
                            Monoid.Unit.t
                          val keys : 'a t -> key List.t
                          val data : 'b t -> 'List.t
                          val filter_keys_inplace :
                            'a t -> f:(key -> bool) -> Monoid.Unit.t
                          val filter_inplace :
                            'b t -> f:('-> bool) -> Monoid.Unit.t
                          val filteri_inplace :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> Monoid.Unit.t
                          val map_inplace :
                            'b t -> f:('-> 'b) -> Monoid.Unit.t
                          val mapi_inplace :
                            'b t ->
                            f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                          val filter_map_inplace :
                            'b t -> f:('-> 'Option.t) -> Monoid.Unit.t
                          val filter_mapi_inplace :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) ->
                            Monoid.Unit.t
                          val equal :
                            'b t -> 'b t -> ('-> '-> bool) -> bool
                          val similar :
                            'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                          val to_alist : 'b t -> (key * 'b) List.t
                          val validate :
                            name:(key -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'b t Base__.Validate.check
                          val incr :
                            ?by:Monoid.Int.t ->
                            ?remove_if_zero:bool ->
                            Monoid.Int.t t -> key -> Monoid.Unit.t
                          val decr :
                            ?by:Monoid.Int.t ->
                            ?remove_if_zero:bool ->
                            Monoid.Int.t t -> key -> Monoid.Unit.t
                          val add_multi :
                            'List.t t ->
                            key:key -> data:'-> Monoid.Unit.t
                          val remove_multi :
                            'List.t t -> key -> Monoid.Unit.t
                          val find_multi : 'List.t t -> key -> 'List.t
                          module Provide_of_sexp :
                            functor
                              (Key : sig
                                       val t_of_sexp :
                                         Ppx_sexp_conv_lib.Sexp.t -> key
                                     end->
                              sig
                                val t_of_sexp :
                                  (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_) ->
                                  Ppx_sexp_conv_lib.Sexp.t -> 'v_x__001_ t
                              end
                          module Provide_bin_io :
                            functor
                              (Key : sig
                                       val bin_t : key Bin_prot.Type_class.t
                                       val bin_read_t :
                                         key Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> key)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         key Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         key Bin_prot.Size.sizer
                                       val bin_write_t :
                                         key Bin_prot.Write.writer
                                       val bin_writer_t :
                                         key Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_t :
                                  'Bin_prot.Type_class.t ->
                                  'a t Bin_prot.Type_class.t
                                val bin_read_t :
                                  'Bin_prot.Read.reader ->
                                  'a t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  'Bin_prot.Read.reader ->
                                  (Core_kernel__.Import.int -> 'a t)
                                  Bin_prot.Read.reader
                                val bin_reader_t :
                                  'Bin_prot.Type_class.reader ->
                                  'a t Bin_prot.Type_class.reader
                                val bin_size_t :
                                  'Bin_prot.Size.sizer ->
                                  'a t Bin_prot.Size.sizer
                                val bin_write_t :
                                  'Bin_prot.Write.writer ->
                                  'a t Bin_prot.Write.writer
                                val bin_writer_t :
                                  'Bin_prot.Type_class.writer ->
                                  'a t Bin_prot.Type_class.writer
                                val bin_shape_t :
                                  Bin_prot.Shape.t -> Bin_prot.Shape.t
                              end
                          val t_of_sexp :
                            (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) ->
                            Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_ t
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                      module Hash_set :
                        sig
                          type elt = t
                          type t = elt Core_kernel__.Hash_set.t
                          val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
                          type 'a t_ = t
                          type 'a elt_ = elt
                          val create :
                            ('a, Monoid.Unit.t -> t)
                            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                          val of_list :
                            ('a, elt List.t -> t)
                            Core_kernel__.Hash_set_intf.create_options_without_first_class_module
                          module Provide_of_sexp :
                            functor
                              (X : sig
                                     val t_of_sexp :
                                       Ppx_sexp_conv_lib.Sexp.t -> elt
                                   end->
                              sig
                                val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                              end
                          module Provide_bin_io :
                            functor
                              (X : sig
                                     val bin_t : elt Bin_prot.Type_class.t
                                     val bin_read_t :
                                       elt Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> elt)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       elt Bin_prot.Type_class.reader
                                     val bin_size_t : elt Bin_prot.Size.sizer
                                     val bin_write_t :
                                       elt Bin_prot.Write.writer
                                     val bin_writer_t :
                                       elt Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                              sig
                                val bin_t : t Bin_prot.Type_class.t
                                val bin_read_t : t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  (Core_kernel__.Import.int -> t)
                                  Bin_prot.Read.reader
                                val bin_reader_t :
                                  t Bin_prot.Type_class.reader
                                val bin_size_t : t Bin_prot.Size.sizer
                                val bin_write_t : t Bin_prot.Write.writer
                                val bin_writer_t :
                                  t Bin_prot.Type_class.writer
                                val bin_shape_t : Bin_prot.Shape.t
                              end
                          val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Monoid.Int.t -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                      module Hash_queue :
                        sig
                          module Key :
                            sig
                              type t = id
                              val compare : t -> t -> Monoid.Int.t
                              val sexp_of_t :
                                t -> Base__.Ppx_sexp_conv_lib.Sexp.t
                              val hash : t -> Monoid.Int.t
                            end
                          type 'a t
                          val sexp_of_t :
                            ('-> Ppx_sexp_conv_lib.Sexp.t) ->
                            'a t -> Ppx_sexp_conv_lib.Sexp.t
                          val length : 'a t -> Monoid.Int.t
                          val is_empty : 'a t -> bool
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            'a t ->
                            init:'accum ->
                            f:('accum -> '-> 'accum) -> 'accum
                          val fold_result :
                            'a t ->
                            init:'accum ->
                            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val fold_until :
                            'a t ->
                            init:'accum ->
                            f:('accum ->
                               '->
                               ('accum, 'final)
                               Base__.Container_intf.Continue_or_stop.t) ->
                            finish:('accum -> 'final) -> 'final
                          val exists : 'a t -> f:('-> bool) -> bool
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            'a t -> f:('-> 'sum) -> 'sum
                          val find : 'a t -> f:('-> bool) -> 'Option.t
                          val find_map :
                            'a t -> f:('-> 'Option.t) -> 'Option.t
                          val to_list : 'a t -> 'List.t
                          val to_array : 'a t -> 'a array
                          val min_elt :
                            'a t ->
                            compare:('-> '-> Monoid.Int.t) -> 'Option.t
                          val max_elt :
                            'a t ->
                            compare:('-> '-> Monoid.Int.t) -> 'Option.t
                          val invariant : 'a t -> Core_kernel__.Import.unit
                          val create :
                            ?growth_allowed:Core_kernel__.Import.bool ->
                            ?size:Core_kernel__.Import.int ->
                            Core_kernel__.Import.unit -> 'a t
                          val clear : 'a t -> Core_kernel__.Import.unit
                          val mem : 'a t -> id -> Core_kernel__.Import.bool
                          val lookup :
                            'a t -> id -> 'Core_kernel__.Import.option
                          val lookup_exn : 'a t -> id -> 'a
                          val enqueue :
                            'a t ->
                            id -> '-> [ `Key_already_present | `Ok ]
                          val enqueue_exn :
                            'a t -> id -> '-> Core_kernel__.Import.unit
                          val lookup_and_move_to_back :
                            'a t -> id -> 'Core_kernel__.Import.option
                          val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                          val first : 'a t -> 'Core_kernel__.Import.option
                          val first_with_key :
                            'a t -> (id * 'a) Core_kernel__.Import.option
                          val keys : 'a t -> id Core_kernel__.Import.list
                          val dequeue :
                            'a t -> 'Core_kernel__.Import.option
                          val dequeue_exn : 'a t -> 'a
                          val dequeue_with_key :
                            'a t -> (id * 'a) Core_kernel__.Import.option
                          val dequeue_with_key_exn : 'a t -> id * 'a
                          val dequeue_all :
                            'a t ->
                            f:('-> Core_kernel__.Import.unit) ->
                            Core_kernel__.Import.unit
                          val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                          val remove_exn :
                            'a t -> id -> Core_kernel__.Import.unit
                          val replace :
                            'a t -> id -> '-> [ `No_such_key | `Ok ]
                          val replace_exn :
                            'a t -> id -> '-> Core_kernel__.Import.unit
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                            Core_kernel__.Import.unit
                          val foldi :
                            'a t ->
                            init:'->
                            f:('-> key:id -> data:'-> 'b) -> 'b
                        end
                    end
                  val global : Monads.Std.Monad.State.Multi.S2.id
                  val fork : unit -> (unit, 'e) t
                  val switch :
                    Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
                  val parent :
                    unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
                  val ancestor :
                    Monads.Std.Monad.State.Multi.S2.id list ->
                    (Monads.Std.Monad.State.Multi.S2.id, 'e) t
                  val current :
                    unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
                  val kill :
                    Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
                  val forks :
                    unit ->
                    (Monads.Std.Monad.State.Multi.S2.id
                     Core_kernel.Sequence.t, 'e)
                    t
                  val status :
                    Monads.Std.Monad.State.Multi.S2.id ->
                    (Monads.Std.Monad.State.Multi.status, 'e) t
                  val lift : 'a m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                      val iter :
                        'Seq.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Seq.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Seq.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                      val filter_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_unit :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  val put : '-> (Monoid.Unit.t, 's) t
                  val get : Monoid.Unit.t -> ('s, 's) t
                  val gets : ('-> 'r) -> ('r, 's) t
                  val update : ('-> 's) -> (Monoid.Unit.t, 's) t
                end
              module T1 :
                functor (T : Core_kernel.T) (M : Monad->
                  sig
                    type env = T.t
                    type 'a m = 'M.t
                    type 'a t =
                        (('a,
                          Monads.Std.Monad.State.Multi.T1.env
                          Monads.Std.Monad.State.Multi.contexts)
                         Monads.Std.Monad.State.storage
                         Monads.Std.Monad.State.Multi.T1.m,
                         Monads.Std.Monad.State.Multi.T1.env
                         Monads.Std.Monad.State.Multi.contexts)
                        Monads.Std.Monad.State.state
                    type 'a e =
                        Monads.Std.Monad.State.Multi.T1.env ->
                        ('a * Monads.Std.Monad.State.Multi.T1.env)
                        Monads.Std.Monad.State.Multi.T1.m
                  end
              module T2 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type ('a, 'e) t =
                        (('a, 'Monads.Std.Monad.State.Multi.contexts)
                         Monads.Std.Monad.State.storage
                         Monads.Std.Monad.State.Multi.T2.m,
                         'Monads.Std.Monad.State.Multi.contexts)
                        Monads.Std.Monad.State.state
                    type ('a, 'e) e =
                        '-> ('a * 'e) Monads.Std.Monad.State.Multi.T2.m
                  end
              module Make :
                functor (T : Core_kernel.T) (M : Monad->
                  sig
                    val global : id
                    val fork : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                    val switch : id -> Monoid.Unit.t T1(T)(M).t
                    val parent : Monoid.Unit.t -> id T1(T)(M).t
                    val ancestor : id List.t -> id T1(T)(M).t
                    val current : Monoid.Unit.t -> id T1(T)(M).t
                    val kill : id -> Monoid.Unit.t T1(T)(M).t
                    val forks : Monoid.Unit.t -> id Seq.t T1(T)(M).t
                    val status : id -> status T1(T)(M).t
                    val lift : 'M.t -> 'T1(T)(M).t
                    val run : 'T1(T)(M).t -> 'T1(T)(M).e
                    val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t List.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(T)(M).t
                        val ignore :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val nothing :
                          Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val non :
                          ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val compose :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(T)(M).t
                        val unary :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                          catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'a t ->
                              f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'b t T1(T)(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          'T1(T)(M).t List.t -> 'List.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t List.t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t List.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'List.t ->
                          f:('-> 'T1(T)(M).t) -> 'List.t T1(T)(M).t
                        val iter :
                          'List.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'List.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'List.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'List.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'List.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'List.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'List.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> 'List.t T1(T)(M).t
                        val filter_map :
                          'List.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'List.t T1(T)(M).t
                      end
                    module Seq :
                      sig
                        val all : 'T1(T)(M).t Seq.t -> 'Seq.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t Seq.t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t Seq.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'Seq.t ->
                          f:('-> 'T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                        val iter :
                          'Seq.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'Seq.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'Seq.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'Seq.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'Seq.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Seq.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'Seq.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                        val filter_map :
                          'Seq.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Seq.t T1(T)(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                      end
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val return : '-> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                    val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_unit :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val bind :
                              'T1(T)(M).t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val map :
                              'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                            val both :
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    val put : T.t -> Monoid.Unit.t T1(T)(M).t
                    val get : Monoid.Unit.t -> T.t T1(T)(M).t
                    val gets : (T.t -> 'r) -> 'T1(T)(M).t
                    val update : (T.t -> T.t) -> Monoid.Unit.t T1(T)(M).t
                  end
              module Make2 :
                functor (M : Monad->
                  sig
                    val global : id
                    val fork : Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val switch : id -> (Monoid.Unit.t, 'e) T2(M).t
                    val parent : Monoid.Unit.t -> (id, 'e) T2(M).t
                    val ancestor : id List.t -> (id, 'e) T2(M).t
                    val current : Monoid.Unit.t -> (id, 'e) T2(M).t
                    val kill : id -> (Monoid.Unit.t, 'e) T2(M).t
                    val forks : Monoid.Unit.t -> (id Seq.t, 'e) T2(M).t
                    val status : id -> (status, 'e) T2(M).t
                    val lift : 'M.t -> ('a, 'e) T2(M).t
                    val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t List.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t List.t -> ('List.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t List.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t List.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'List.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('List.t, 'e) T2(M).t
                        val iter :
                          'List.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'List.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'List.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'List.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'List.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'List.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'List.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'List.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'List.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'List.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'List.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'List.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('List.t, 'e) T2(M).t
                        val filter_map :
                          'List.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('List.t, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Seq.t -> ('Seq.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Seq.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t Seq.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Seq.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Seq.t, 'e) T2(M).t
                        val iter :
                          'Seq.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Seq.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Seq.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Seq.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Seq.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Seq.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Seq.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Seq.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Seq.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Seq.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Seq.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Seq.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Seq.t, 'e) T2(M).t
                        val filter_map :
                          'Seq.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Seq.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_unit :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    val put : '-> (Monoid.Unit.t, 's) T2(M).t
                    val get : Monoid.Unit.t -> ('s, 's) T2(M).t
                    val gets : ('-> 'r) -> ('r, 's) T2(M).t
                    val update : ('-> 's) -> (Monoid.Unit.t, 's) T2(M).t
                  end
            end
          type ('a, 'e) t = (('a, 'e) storage, 'e) state
          type 'a m = 'a
          type ('a, 'e) e = '-> 'a * 'e
          val lift : '-> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val sequence :
            (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                f:(Monoid.Unit.t -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) t t -> ('a t, 'e) t
                  val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                  val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                  val iter :
                    'a t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists : 'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'a t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter : 'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                  val filter_map :
                    'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter :
                'List.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'List.t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter :
                'Seq.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Seq.t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_unit : (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          val all_ignore :
            (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val put : '-> (Monoid.Unit.t, 's) t
          val get : Monoid.Unit.t -> ('s, 's) t
          val gets : ('-> 'r) -> ('r, 's) t
          val update : ('-> 's) -> (Monoid.Unit.t, 's) t
          val eval : ('a, 'e) t -> '-> 'a
          val exec : ('a, 'e) t -> '-> 'e
          module T1 :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                type env = T.t
                type 'a m = 'M.t
                type 'a t =
                    (('a, Monads.Std.Monad.State.T1.env)
                     Monads.Std.Monad.State.storage
                     Monads.Std.Monad.State.T1.m,
                     Monads.Std.Monad.State.T1.env)
                    Monads.Std.Monad.State.state
                type 'a e =
                    Monads.Std.Monad.State.T1.env ->
                    ('a * Monads.Std.Monad.State.T1.env)
                    Monads.Std.Monad.State.T1.m
              end
          module T2 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type ('a, 'e) t =
                    (('a, 'e) Monads.Std.Monad.State.storage
                     Monads.Std.Monad.State.T2.m, 'e)
                    Monads.Std.Monad.State.state
                type ('a, 'e) e = '-> ('a * 'e) Monads.Std.Monad.State.T2.m
              end
          module Make :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                val lift : 'M.t -> 'T1(T)(M).t
                val run : 'T1(T)(M).t -> 'T1(T)(M).e
                val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val sequence :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(T)(M).t
                    val ignore : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                    val non :
                      ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val compose :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(T)(M).t
                    val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                      catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'a list ->
                      f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                  end
                val bind :
                  'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val return : '-> 'T1(T)(M).t
                val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_unit :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val all_ignore :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val both :
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                val put : T.t -> Monoid.Unit.t T1(T)(M).t
                val get : Monoid.Unit.t -> T.t T1(T)(M).t
                val gets : (T.t -> 'r) -> 'T1(T)(M).t
                val update : (T.t -> T.t) -> Monoid.Unit.t T1(T)(M).t
              end
          module Make2 :
            functor (M : Monad->
              sig
                val lift : 'M.t -> ('a, 'e) T2(M).t
                val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                val put : '-> (Monoid.Unit.t, 's) T2(M).t
                val get : Monoid.Unit.t -> ('s, 's) T2(M).t
                val gets : ('-> 'r) -> ('r, 's) T2(M).t
                val update : ('-> 's) -> (Monoid.Unit.t, 's) T2(M).t
              end
        end
      module Fun :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type ('a, 'e) m
              type ('a, 'e) e
              val lift : ('a, 'e) m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
            end
          type 'a thunk
          type 'a t = 'a thunk
          type 'a m = 'a
          type 'a e = 'a
          val lift : '-> 'a t
          val run : 'a t -> 'a
          val void : 'a t -> Monoid.Unit.t t
          val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> Monoid.Unit.t t
              val nothing : Monoid.Unit.t -> Monoid.Unit.t t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times :
                n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : 'a thunk t -> 'a t thunk
                  val all_ignore : 'a thunk t -> Monoid.Unit.t thunk
                  val sequence : Monoid.Unit.t thunk t -> Monoid.Unit.t thunk
                  val map : 'a t -> f:('-> 'b thunk) -> 'b t thunk
                  val iter :
                    'a t ->
                    f:('-> Monoid.Unit.t thunk) -> Monoid.Unit.t thunk
                  val fold :
                    'a t -> init:'-> f:('-> '-> 'b thunk) -> 'b thunk
                  val fold_left :
                    'a t -> init:'-> f:('-> '-> 'b thunk) -> 'b thunk
                  val fold_right :
                    'a t -> f:('-> '-> 'b thunk) -> init:'-> 'b thunk
                  val reduce :
                    'a t -> f:('-> '-> 'a thunk) -> 'Option.t thunk
                  val exists : 'a t -> f:('-> bool thunk) -> bool thunk
                  val for_all : 'a t -> f:('-> bool thunk) -> bool thunk
                  val count :
                    'a t -> f:('-> bool thunk) -> Monoid.Int.t thunk
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> 'a thunk) -> 'a thunk
                  val find :
                    'a t -> f:('-> bool thunk) -> 'Option.t thunk
                  val find_map :
                    'a t -> f:('-> 'Option.t thunk) -> 'Option.t thunk
                  val filter : 'a t -> f:('-> bool thunk) -> 'a t thunk
                  val filter_map :
                    'a t -> f:('-> 'Option.t thunk) -> 'b t thunk
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter :
                'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter :
                'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> Monoid.Unit.t t
          val all : 'a t list -> 'a list t
          val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
          val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module T1 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type 'a t =
                    'Monads.Std.Monad.Fun.T1.m Monads.Std.Monad.Fun.thunk
                type 'a e = 'Monads.Std.Monad.Fun.T1.m
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T1(M).t
                val run : 'T1(M).t -> 'Monads.Std.Monad.Fun.T1.m
                val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val sequence :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val forever : 'T1(M).t -> 'T1(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(M).t
                    val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                    val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val compose :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(M).t
                    val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(M).t) ->
                      catch:(exn -> 'T1(M).t) -> 'T1(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(M).t t -> 'a t T1(M).t
                        val all_ignore :
                          'T1(M).t t -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t t -> Monoid.Unit.t T1(M).t
                        val map :
                          'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore : 'T1(M).t list -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val map :
                      'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(M).t
                    val all_ignore :
                      'T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                  end
                val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                val return : '-> 'T1(M).t
                val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                val join : 'T1(M).t T1(M).t -> 'T1(M).t
                val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_unit :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val all_ignore :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val bind :
                          'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                        val both :
                          'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
              end
          module T2 :
            functor (M : Monad2->
              sig
                type ('a, 'e) m = ('a, 'e) M.t
                type ('a, 'e) t =
                    ('a, 'e) Monads.Std.Monad.Fun.T2.m
                    Monads.Std.Monad.Fun.thunk
                type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Fun.T2.m
              end
          module Make2 :
            functor (M : Monad2->
              sig
                val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                val run :
                  ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Fun.T2.m
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
              end
        end
      module Lazy :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type ('a, 'e) m
              type ('a, 'e) e
              val lift : ('a, 'e) m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
            end
          type 'a t = 'Core_kernel.Lazy.t
          type 'a m = 'a
          type 'a e = 'a
          val lift : '-> 'a t
          val run : 'a t -> 'a
          val void : 'a t -> Monoid.Unit.t t
          val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
          val forever : 'a t -> 'b t
          module Fn :
            sig
              val id : '-> 'a t
              val ignore : 'a t -> Monoid.Unit.t t
              val nothing : Monoid.Unit.t -> Monoid.Unit.t t
              val non : ('-> bool t) -> '-> bool t
              val apply_n_times :
                n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
              val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
            end
          module Pair :
            sig
              val fst : ('a * 'b) t -> 'a t
              val snd : ('a * 'b) t -> 'b t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c) t -> 'a t
              val snd : ('a * 'b * 'c) t -> 'b t
              val trd : ('a * 'b * 'c) t -> 'c t
            end
          module Lift :
            sig
              val nullary : '-> 'a t
              val unary : ('-> 'b) -> 'a t -> 'b t
              val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ternary :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all :
                    'Core_kernel.Lazy.t t -> 'a t Core_kernel.Lazy.t
                  val all_ignore :
                    'Core_kernel.Lazy.t t ->
                    Monoid.Unit.t Core_kernel.Lazy.t
                  val sequence :
                    Monoid.Unit.t Core_kernel.Lazy.t t ->
                    Monoid.Unit.t Core_kernel.Lazy.t
                  val map :
                    'a t ->
                    f:('-> 'Core_kernel.Lazy.t) ->
                    'b t Core_kernel.Lazy.t
                  val iter :
                    'a t ->
                    f:('-> Monoid.Unit.t Core_kernel.Lazy.t) ->
                    Monoid.Unit.t Core_kernel.Lazy.t
                  val fold :
                    'a t ->
                    init:'->
                    f:('-> '-> 'Core_kernel.Lazy.t) ->
                    'Core_kernel.Lazy.t
                  val fold_left :
                    'a t ->
                    init:'->
                    f:('-> '-> 'Core_kernel.Lazy.t) ->
                    'Core_kernel.Lazy.t
                  val fold_right :
                    'a t ->
                    f:('-> '-> 'Core_kernel.Lazy.t) ->
                    init:'-> 'Core_kernel.Lazy.t
                  val reduce :
                    'a t ->
                    f:('-> '-> 'Core_kernel.Lazy.t) ->
                    'Option.t Core_kernel.Lazy.t
                  val exists :
                    'a t ->
                    f:('-> bool Core_kernel.Lazy.t) ->
                    bool Core_kernel.Lazy.t
                  val for_all :
                    'a t ->
                    f:('-> bool Core_kernel.Lazy.t) ->
                    bool Core_kernel.Lazy.t
                  val count :
                    'a t ->
                    f:('-> bool Core_kernel.Lazy.t) ->
                    Monoid.Int.t Core_kernel.Lazy.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t ->
                    f:('-> 'Core_kernel.Lazy.t) -> 'Core_kernel.Lazy.t
                  val find :
                    'a t ->
                    f:('-> bool Core_kernel.Lazy.t) ->
                    'Option.t Core_kernel.Lazy.t
                  val find_map :
                    'a t ->
                    f:('-> 'Option.t Core_kernel.Lazy.t) ->
                    'Option.t Core_kernel.Lazy.t
                  val filter :
                    'a t ->
                    f:('-> bool Core_kernel.Lazy.t) ->
                    'a t Core_kernel.Lazy.t
                  val filter_map :
                    'a t ->
                    f:('-> 'Option.t Core_kernel.Lazy.t) ->
                    'b t Core_kernel.Lazy.t
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : 'a t T.t -> 'T.t t
                    val all_ignore : 'a t T.t -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                    val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                    val iter :
                      'T.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                    val exists : 'T.t -> f:('-> bool t) -> bool t
                    val for_all : 'T.t -> f:('-> bool t) -> bool t
                    val count : 'T.t -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> 'a t) -> 'a t
                    val find : 'T.t -> f:('-> bool t) -> 'Option.t t
                    val find_map :
                      'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                    val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                    val filter_map :
                      'T.t -> f:('-> 'Option.t t) -> 'T.t t
                  end
            end
          module List :
            sig
              val all : 'a t List.t -> 'List.t t
              val all_ignore : 'a t List.t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val map : 'List.t -> f:('-> 'b t) -> 'List.t t
              val iter :
                'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
              val fold : 'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'List.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'List.t -> f:('-> bool t) -> bool t
              val for_all : 'List.t -> f:('-> bool t) -> bool t
              val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> 'a t) -> 'a t
              val find : 'List.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'List.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'List.t -> f:('-> bool t) -> 'List.t t
              val filter_map :
                'List.t -> f:('-> 'Option.t t) -> 'List.t t
            end
          module Seq :
            sig
              val all : 'a t Seq.t -> 'Seq.t t
              val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
              val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
              val iter :
                'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
              val fold : 'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_left :
                'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
              val fold_right :
                'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
              val reduce : 'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
              val exists : 'Seq.t -> f:('-> bool t) -> bool t
              val for_all : 'Seq.t -> f:('-> bool t) -> bool t
              val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> 'a t) -> 'a t
              val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
              val find_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
              val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
              val filter_map :
                'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
            end
          val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
          val ( !! ) : '-> 'a t
          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
          val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
          module Monad_infix :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
            end
          val bind : 'a t -> f:('-> 'b t) -> 'b t
          val return : '-> 'a t
          val map : 'a t -> f:('-> 'b) -> 'b t
          val join : 'a t t -> 'a t
          val ignore_m : 'a t -> Monoid.Unit.t t
          val all : 'a t list -> 'a list t
          val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
          val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
          module Let_syntax :
            sig
              val return : '-> 'a t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val both : 'a t -> 'b t -> ('a * 'b) t
                  module Open_on_rhs : sig  end
                end
            end
          module Syntax :
            sig
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
            end
          module T1 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type 'a t = 'Monads.Std.Monad.Lazy.T1.m Core_kernel.Lazy.t
                type 'a e = 'Monads.Std.Monad.Lazy.T1.m
              end
          module Make :
            functor (M : Monad->
              sig
                val lift : 'M.t -> 'T1(M).t
                val run : 'T1(M).t -> 'Monads.Std.Monad.Lazy.T1.m
                val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val sequence :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val forever : 'T1(M).t -> 'T1(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(M).t
                    val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                    val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val compose :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                    val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(M).t
                    val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(M).t) ->
                      catch:(exn -> 'T1(M).t) -> 'T1(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(M).t t -> 'a t T1(M).t
                        val all_ignore :
                          'T1(M).t t -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t t -> Monoid.Unit.t T1(M).t
                        val map :
                          'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(M).t T.t -> 'T.t T1(M).t
                          val all_ignore :
                            'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                          val sequence :
                            Monoid.Unit.t T1(M).t T.t ->
                            Monoid.Unit.t T1(M).t
                          val map :
                            'T.t -> f:('-> 'T1(M).t) -> 'T.t T1(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(M).t) ->
                            Monoid.Unit.t T1(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(M).t) -> 'T1(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) ->
                            init:'-> 'T1(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                          val exists :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val for_all :
                            'T.t -> f:('-> bool T1(M).t) -> bool T1(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) ->
                            'Option.t T1(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(M).t) -> 'T.t T1(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(M).t) -> 'T.t T1(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore : 'T1(M).t list -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val map :
                      'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'a list -> f:('-> bool T1(M).t) -> 'a list T1(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(M).t
                    val all_ignore :
                      'T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(M).t) ->
                      Monoid.Unit.t T1(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> bool T1(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(M).t) -> 'T1(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(M).t) -> 'Option.t T1(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(M).t) ->
                      'Core_kernel.Sequence.t T1(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(M).t) ->
                  ('-> 'T1(M).t) -> '-> 'T1(M).t
                val ( !! ) : '-> 'T1(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(M).t ->
                  'T1(M).t ->
                  'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                val ( >>= ) : 'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                  end
                val bind : 'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                val return : '-> 'T1(M).t
                val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                val join : 'T1(M).t T1(M).t -> 'T1(M).t
                val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                val all : 'T1(M).t list -> 'a list T1(M).t
                val all_unit :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                val all_ignore :
                  Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val bind :
                          'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                        val both :
                          'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
              end
          module T2 :
            functor (M : Monad2->
              sig
                type ('a, 'e) m = ('a, 'e) M.t
                type ('a, 'e) t =
                    ('a, 'e) Monads.Std.Monad.Lazy.T2.m Core_kernel.Lazy.t
                type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Lazy.T2.m
              end
          module Make2 :
            functor (M : Monad2->
              sig
                val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                val run :
                  ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Lazy.T2.m
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
              end
        end
      module Cont :
        sig
          module type S =
            sig
              type 'a t
              type 'a m
              type 'a e
              val lift : 'a m -> 'a t
              val run : 'a t -> 'a e
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'Option.t t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_unit : Monoid.Unit.t t list -> Monoid.Unit.t t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              type r
              val call : f:(cc:('-> 'b t) -> 'a t) -> 'a t
            end
          module type S2 =
            sig
              type ('a, 'e) t
              type 'a m
              type ('a, 'e) e
              val lift : 'a m -> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_unit :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val call :
                f:(cc:('-> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
            end
          type ('a, 'r) cont
          type ('a, 'r) t = ('a, 'r) cont
          type 'a m = 'a
          type ('a, 'e) e = ('-> 'e) -> 'e
          val lift : '-> ('a, 'e) t
          val run : ('a, 'e) t -> ('a, 'e) e
          val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val sequence :
            (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
          val forever : ('a, 'e) t -> ('b, 'e) t
          module Fn :
            sig
              val id : '-> ('a, 'e) t
              val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
              val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
              val apply_n_times :
                n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
              val compose :
                ('-> ('c, 'e) t) -> ('-> ('b, 'e) t) -> '-> ('c, 'e) t
            end
          module Pair :
            sig
              val fst : ('a * 'b, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b, 'e) t -> ('b, 'e) t
            end
          module Triple :
            sig
              val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
              val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
              val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
            end
          module Lift :
            sig
              val nullary : '-> ('a, 'e) t
              val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val binary :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ternary :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val quaternary :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val quinary :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          module Exn :
            sig
              val expect :
                ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                f:(Monoid.Unit.t -> ('a, 's) t) ->
                catch:(exn -> ('a, 's) t) -> ('a, 's) t
            end
          module Collection :
            sig
              module type S =
                sig
                  type 'a t
                  val all : ('a, 'e) cont t -> ('a t, 'e) cont
                  val all_ignore :
                    ('a, 'e) cont t -> (Monoid.Unit.t, 'e) cont
                  val sequence :
                    (Monoid.Unit.t, 'e) cont t -> (Monoid.Unit.t, 'e) cont
                  val map :
                    'a t -> f:('-> ('b, 'e) cont) -> ('b t, 'e) cont
                  val iter :
                    'a t ->
                    f:('-> (Monoid.Unit.t, 'e) cont) ->
                    (Monoid.Unit.t, 'e) cont
                  val fold :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) cont) -> ('b, 'e) cont
                  val fold_left :
                    'a t ->
                    init:'-> f:('-> '-> ('b, 'e) cont) -> ('b, 'e) cont
                  val fold_right :
                    'a t ->
                    f:('-> '-> ('b, 'e) cont) -> init:'-> ('b, 'e) cont
                  val reduce :
                    'a t ->
                    f:('-> '-> ('a, 'e) cont) -> ('Option.t, 'e) cont
                  val exists :
                    'a t -> f:('-> (bool, 'e) cont) -> (bool, 'e) cont
                  val for_all :
                    'a t -> f:('-> (bool, 'e) cont) -> (bool, 'e) cont
                  val count :
                    'a t ->
                    f:('-> (bool, 'e) cont) -> (Monoid.Int.t, 'e) cont
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b t -> f:('-> ('a, 'e) cont) -> ('a, 'e) cont
                  val find :
                    'a t ->
                    f:('-> (bool, 'e) cont) -> ('Option.t, 'e) cont
                  val find_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) cont) ->
                    ('Option.t, 'e) cont
                  val filter :
                    'a t -> f:('-> (bool, 'e) cont) -> ('a t, 'e) cont
                  val filter_map :
                    'a t ->
                    f:('-> ('Option.t, 'e) cont) -> ('b t, 'e) cont
                end
              module Eager :
                functor (T : Collection.Eager->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
              module Delay :
                functor (T : Collection.Delay->
                  sig
                    val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                    val all_ignore : ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                    val map :
                      'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                    val iter :
                      'T.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'T.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'T.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'T.t ->
                      f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                    val exists :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'T.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'T.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                    val find_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                    val filter :
                      'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                    val filter_map :
                      'T.t ->
                      f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                  end
            end
          module List :
            sig
              val all : ('a, 'e) t List.t -> ('List.t, 'e) t
              val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val map :
                'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
              val iter :
                'List.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'List.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'List.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'List.t ->
                f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'List.t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'List.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
              val filter_map :
                'List.t ->
                f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
            end
          module Seq :
            sig
              val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
              val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
              val map : 'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
              val iter :
                'Seq.t ->
                f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
              val fold :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_left :
                'Seq.t ->
                init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
              val fold_right :
                'Seq.t ->
                f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
              val reduce :
                'Seq.t -> f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
              val exists : 'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val for_all :
                'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
              val count :
                'Seq.t -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
              val map_reduce :
                (module Monoid.S with type t = 'a) ->
                'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
              val find :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
              val find_map :
                'Seq.t ->
                f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
              val filter :
                'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
              val filter_map :
                'Seq.t -> f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
            end
          val ( >=> ) :
            ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
          val ( !! ) : '-> ('a, 'e) t
          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
          val ( !$$ ) :
            ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
          val ( !$$$ ) :
            ('-> '-> '-> 'd) ->
            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
          val ( !$$$$ ) :
            ('-> '-> '-> '-> 'e) ->
            ('a, 's) t ->
            ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
          val ( !$$$$$ ) :
            ('-> '-> '-> '-> '-> 'f) ->
            ('a, 's) t ->
            ('b, 's) t ->
            ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
          module Let_syntax :
            sig
              val return : '-> ('a, 'b) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                  module Open_on_rhs : sig  end
                end
            end
          module Monad_infix :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
            end
          val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
          val return : '-> ('a, 'b) t
          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
          val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
          val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
          val all : ('a, 'e) t list -> ('a list, 'e) t
          val all_unit : (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          val all_ignore :
            (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
          module Syntax :
            sig
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
            end
          val call : f:(cc:('-> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
          module T1 :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                type r = T.t
                type 'a m = 'M.t
                type 'a t =
                    ('a,
                     Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m)
                    Monads.Std.Monad.Cont.cont
                type 'a e =
                    ('->
                     Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m) ->
                    Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m
              end
          module T2 :
            functor (M : Monad->
              sig
                type 'a m = 'M.t
                type ('a, 'e) t =
                    ('a, 'Monads.Std.Monad.Cont.T2.m)
                    Monads.Std.Monad.Cont.cont
                type ('a, 'e) e =
                    ('-> 'Monads.Std.Monad.Cont.T2.m) ->
                    'Monads.Std.Monad.Cont.T2.m
              end
          module Make :
            functor (T : Core_kernel.T) (M : Monad->
              sig
                val lift : 'M.t -> 'T1(T)(M).t
                val run : 'T1(T)(M).t -> 'T1(T)(M).e
                val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val sequence :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                module Fn :
                  sig
                    val id : '-> 'T1(T)(M).t
                    val ignore : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                    val non :
                      ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val compose :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                    val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'T1(T)(M).t
                    val unary : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                      f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                      catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a t -> f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a t ->
                          f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                        val filter_map :
                          'a t ->
                          f:('-> 'Option.t T1(T)(M).t) -> 'b t T1(T)(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                          val all_ignore :
                            'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                          val sequence :
                            Monoid.Unit.t T1(T)(M).t T.t ->
                            Monoid.Unit.t T1(T)(M).t
                          val map :
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t T1(T)(M).t) ->
                            Monoid.Unit.t T1(T)(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            init:'-> 'T1(T)(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> 'T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val exists :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val for_all :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                          val count :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            Monoid.Int.t T1(T)(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                          val find :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val find_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'Option.t T1(T)(M).t
                          val filter :
                            'T.t ->
                            f:('-> bool T1(T)(M).t) -> 'T.t T1(T)(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> 'Option.t T1(T)(M).t) ->
                            'T.t T1(T)(M).t
                        end
                  end
                module List :
                  sig
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'a list ->
                      f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'a list -> f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'a list ->
                      f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                    val filter_map :
                      'a list ->
                      f:('-> 'Option.t T1(T)(M).t) -> 'b list T1(T)(M).t
                  end
                module Seq :
                  sig
                    val all :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val all_ignore :
                      'T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t Core_kernel.Sequence.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> Monoid.Unit.t T1(T)(M).t) ->
                      Monoid.Unit.t T1(T)(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) ->
                      init:'-> 'T1(T)(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> 'T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> Monoid.Int.t T1(T)(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Option.t T1(T)(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> bool T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> 'Option.t T1(T)(M).t) ->
                      'Core_kernel.Sequence.t T1(T)(M).t
                  end
                val ( >=> ) :
                  ('-> 'T1(T)(M).t) ->
                  ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                val ( !! ) : '-> 'T1(T)(M).t
                val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t ->
                  'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                val ( >>= ) :
                  'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val ( >>| ) : 'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                  end
                val bind :
                  'T1(T)(M).t -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                val return : '-> 'T1(T)(M).t
                val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                val all_unit :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                val all_ignore :
                  Monoid.Unit.t T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                module Let_syntax :
                  sig
                    val return : '-> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val both :
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                  end
                val call :
                  f:(cc:('-> 'T1(T)(M).t) -> 'T1(T)(M).t) ->
                  'T1(T)(M).t
              end
          module Make2 :
            functor (M : Monad->
              sig
                val lift : 'M.t -> ('a, 'e) T2(M).t
                val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                val void : ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val sequence :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) T2(M).t
                    val ignore :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val nothing :
                      Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                    val non :
                      ('-> (bool, 'e) T2(M).t) -> '-> (bool, 'e) T2(M).t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                    val compose :
                      ('-> ('c, 'e) T2(M).t) ->
                      ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val snd : ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val trd : ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) T2(M).t
                    val unary :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) T2(M).t) ->
                      f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                      catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b t, 'e) T2(M).t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a t, 'e) T2(M).t
                        val filter_map :
                          'a t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b t, 'e) T2(M).t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all :
                            ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                          val all_ignore :
                            ('a, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val sequence :
                            (Monoid.Unit.t, 'e) T2(M).t T.t ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                            (Monoid.Unit.t, 'e) T2(M).t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            ('b, 'e) T2(M).t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) T2(M).t) ->
                            init:'-> ('b, 'e) T2(M).t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (bool, 'e) T2(M).t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            (Monoid.Int.t, 'e) T2(M).t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t ->
                            f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val find_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('Option.t, 'e) T2(M).t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                          val filter_map :
                            'T.t ->
                            f:('-> ('Option.t, 'e) T2(M).t) ->
                            ('T.t, 'e) T2(M).t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t list -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'a list ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'a list ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) T2(M).t) -> ('a list, 'e) T2(M).t
                    val filter_map :
                      'a list ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('b list, 'e) T2(M).t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val all_ignore :
                      ('a, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t Core_kernel.Sequence.t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('b, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val iter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val fold :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_left :
                      'Core_kernel.Sequence.t ->
                      init:'->
                      f:('-> '-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val fold_right :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('b, 'e) T2(M).t) ->
                      init:'-> ('b, 'e) T2(M).t
                    val reduce :
                      'Core_kernel.Sequence.t ->
                      f:('-> '-> ('a, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val exists :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val for_all :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                    val count :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      (Monoid.Int.t, 'e) T2(M).t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Sequence.t ->
                      f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                    val find :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val find_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Option.t, 'e) T2(M).t
                    val filter :
                      'Core_kernel.Sequence.t ->
                      f:('-> (bool, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                    val filter_map :
                      'Core_kernel.Sequence.t ->
                      f:('-> ('Option.t, 'e) T2(M).t) ->
                      ('Core_kernel.Sequence.t, 'e) T2(M).t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) T2(M).t) ->
                  ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                val ( !! ) : '-> ('a, 'e) T2(M).t
                val ( !$ ) :
                  ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) T2(M).t ->
                  ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t -> ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) T2(M).t ->
                  ('b, 's) T2(M).t ->
                  ('c, 's) T2(M).t ->
                  ('d, 's) T2(M).t -> ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                val ( >>= ) :
                  ('a, 'e) T2(M).t ->
                  ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val ( >>| ) :
                  ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val both :
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                  end
                val bind :
                  ('a, 'e) T2(M).t ->
                  f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                val return : '-> ('a, 'b) T2(M).t
                val map :
                  ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                val join : (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                val ignore_m :
                  ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                val all_unit :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                val all_ignore :
                  (Monoid.Unit.t, 'e) T2(M).t list ->
                  (Monoid.Unit.t, 'e) T2(M).t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                  end
                val call :
                  f:(cc:('-> ('b, 'e) T2(M).t) -> ('a, 'e) T2(M).t) ->
                  ('a, 'e) T2(M).t
              end
        end
    end
end